dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

use gimp_message where appropriate 

--Sven
This commit is contained in:
Sven Neumann 1999-10-16 03:51:45 +00:00
parent ba3f196538
commit e192fcfe43
3 changed files with 896 additions and 798 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ChangeLog
View File

@ -1,3 +1,8 @@
Sat Oct 16 05:48:44 MEST 1999 Sven Neumann <sven@gimp.org>
* plug-ins/common/compose.c
* plug-ins/common/decompose.c: use gimp_message where appropriate
Thu Oct 14 13:31:59 MEST 1999 Sven Neumann <sven@gimp.org> Thu Oct 14 13:31:59 MEST 1999 Sven Neumann <sven@gimp.org>
* plug-ins/common/sunras.c * plug-ins/common/sunras.c

832
plug-ins/common/compose.c
View File

@ -256,7 +256,7 @@ static void show_message (const char *message)
{ {
if (run_mode == RUN_INTERACTIVE) if (run_mode == RUN_INTERACTIVE)
g_message (message); gimp_message (message);
else else
printf ("%s\n", message); printf ("%s\n", message);
} }
@ -380,396 +380,399 @@ run (char *name,
/* Compose an image from several gray-images */ /* Compose an image from several gray-images */
static gint32 static gint32
compose (char *compose_type, compose (char *compose_type,
gint32 *compose_ID, gint32 *compose_ID,
int compose_by_drawable) int compose_by_drawable)
{
{int width, height, tile_height, scan_lines; int width, height, tile_height, scan_lines;
int num_images, compose_idx, incr_src[MAX_COMPOSE_IMAGES]; int num_images, compose_idx, incr_src[MAX_COMPOSE_IMAGES];
int i, j; int i, j;
gint num_layers; gint num_layers;
gint32 layer_ID_dst, image_ID_dst; gint32 layer_ID_dst, image_ID_dst;
unsigned char *src[MAX_COMPOSE_IMAGES], *dst = (unsigned char *)ident; unsigned char *src[MAX_COMPOSE_IMAGES], *dst = (unsigned char *)ident;
GDrawableType gdtype_dst; GDrawableType gdtype_dst;
GDrawable *drawable_src[MAX_COMPOSE_IMAGES], *drawable_dst; GDrawable *drawable_src[MAX_COMPOSE_IMAGES], *drawable_dst;
GPixelRgn pixel_rgn_src[MAX_COMPOSE_IMAGES], pixel_rgn_dst; GPixelRgn pixel_rgn_src[MAX_COMPOSE_IMAGES], pixel_rgn_dst;
/* Search type of composing */ /* Search type of composing */
compose_idx = -1; compose_idx = -1;
for (j = 0; j < MAX_COMPOSE_TYPES; j++) for (j = 0; j < MAX_COMPOSE_TYPES; j++)
{ {
if (cmp_icase (compose_type, compose_dsc[j].compose_type) == 0) if (cmp_icase (compose_type, compose_dsc[j].compose_type) == 0)
compose_idx = j; compose_idx = j;
} }
if (compose_idx < 0) if (compose_idx < 0)
return (-1); return (-1);
num_images = compose_dsc[compose_idx].num_images; num_images = compose_dsc[compose_idx].num_images;
tile_height = gimp_tile_height (); tile_height = gimp_tile_height ();
/* Check image sizes */ /* Check image sizes */
if (compose_by_drawable) if (compose_by_drawable)
{
width = gimp_drawable_width (compose_ID[0]);
height = gimp_drawable_height (compose_ID[0]);
for (j = 1; j < num_images; j++)
{ {
if ( (width != (int)gimp_drawable_width (compose_ID[j])) width = gimp_drawable_width (compose_ID[0]);
|| (height != (int)gimp_drawable_height (compose_ID[j]))) height = gimp_drawable_height (compose_ID[0]);
{
show_message (_("compose: drawables have different size")); for (j = 1; j < num_images; j++)
return -1; {
} if ( (width != (int)gimp_drawable_width (compose_ID[j]))
|| (height != (int)gimp_drawable_height (compose_ID[j])))
{
show_message (_("compose: drawables have different size"));
return -1;
}
}
for (j = 0; j < num_images; j++)
drawable_src[j] = gimp_drawable_get (compose_ID[j]);
} }
for (j = 0; j < num_images; j++)
drawable_src[j] = gimp_drawable_get (compose_ID[j]);
}
else /* Compose by image ID */ else /* Compose by image ID */
{
width = gimp_image_width (compose_ID[0]);
height = gimp_image_height (compose_ID[0]);
for (j = 1; j < num_images; j++)
{ {
if ( (width != (int)gimp_image_width (compose_ID[j])) width = gimp_image_width (compose_ID[0]);
|| (height != (int)gimp_image_height (compose_ID[j]))) height = gimp_image_height (compose_ID[0]);
{
show_message (_("compose: images have different size")); for (j = 1; j < num_images; j++)
return -1; {
} if ( (width != (int)gimp_image_width (compose_ID[j]))
|| (height != (int)gimp_image_height (compose_ID[j])))
{
show_message (_("compose: images have different size"));
return -1;
}
}
/* Get first layer/drawable for all input images */
for (j = 0; j < num_images; j++)
{gint32 *g32;
/* Get first layer of image */
g32 = gimp_image_get_layers (compose_ID[j], &num_layers);
if ((g32 == NULL) || (num_layers <= 0))
{
show_message (_("compose: error in getting layer IDs"));
return (-1);
}
/* Get drawable for layer */
drawable_src[j] = gimp_drawable_get (g32[0]);
g_free (g32);
}
} }
/* Get first layer/drawable for all input images */
for (j = 0; j < num_images; j++)
{gint32 *g32;
/* Get first layer of image */
g32 = gimp_image_get_layers (compose_ID[j], &num_layers);
if ((g32 == NULL) || (num_layers <= 0))
{
show_message (_("compose: error in getting layer IDs"));
return (-1);
}
/* Get drawable for layer */
drawable_src[j] = gimp_drawable_get (g32[0]);
g_free (g32);
}
}
/* Get pixel region for all input drawables */ /* Get pixel region for all input drawables */
for (j = 0; j < num_images; j++) for (j = 0; j < num_images; j++)
{
/* Check bytes per pixel */
incr_src[j] = drawable_src[j]->bpp;
if ((incr_src[j] != 1) && (incr_src[j] != 2))
{char msg[256];
sprintf (msg, _("compose: image is not a gray image (bpp=%d)"),
incr_src[j]);
show_message (msg);
return (-1);
}
/* Get pixel region */
gimp_pixel_rgn_init (&(pixel_rgn_src[j]), drawable_src[j], 0, 0,
width, height, FALSE, FALSE);
/* Get memory for retrieving information */
src[j] = (unsigned char *)g_malloc (tile_height * width
* drawable_src[j]->bpp);
if (src[j] == NULL)
{ {
/* Check bytes per pixel */
incr_src[j] = drawable_src[j]->bpp;
if ((incr_src[j] != 1) && (incr_src[j] != 2))
{char msg[256];
sprintf (msg, _("compose: image is not a gray image (bpp=%d)"),
incr_src[j]);
show_message (msg);
return (-1);
}
/* Get pixel region */
gimp_pixel_rgn_init (&(pixel_rgn_src[j]), drawable_src[j], 0, 0,
width, height, FALSE, FALSE);
/* Get memory for retrieving information */
src[j] = (unsigned char *)g_malloc (tile_height * width
* drawable_src[j]->bpp);
if (src[j] == NULL)
{
show_message (_("compose: not enough memory"));
return (-1);
}
}
/* Create new image */
gdtype_dst = (compose_dsc[compose_idx].compose_fun == compose_rgba)
? RGBA_IMAGE : RGB_IMAGE;
image_ID_dst = create_new_image (compose_dsc[compose_idx].filename,
width, height, gdtype_dst,
&layer_ID_dst, &drawable_dst, &pixel_rgn_dst);
dst = (unsigned char *)g_malloc (tile_height * width * drawable_dst->bpp);
if (dst == NULL)
{
for (j = 0; j < num_images; j++)
g_free (src[j]);
show_message (_("compose: not enough memory")); show_message (_("compose: not enough memory"));
return (-1); return (-1);
} }
}
/* Create new image */
gdtype_dst = (compose_dsc[compose_idx].compose_fun == compose_rgba)
? RGBA_IMAGE : RGB_IMAGE;
image_ID_dst = create_new_image (compose_dsc[compose_idx].filename,
width, height, gdtype_dst,
&layer_ID_dst, &drawable_dst, &pixel_rgn_dst);
dst = (unsigned char *)g_malloc (tile_height * width * drawable_dst->bpp);
if (dst == NULL)
{
for (j = 0; j < num_images; j++) g_free (src[j]);
show_message (_("compose: not enough memory"));
return (-1);
}
/* Do the composition */ /* Do the composition */
i = 0; i = 0;
while (i < height) while (i < height)
{ {
scan_lines = (i+tile_height-1 < height) ? tile_height : (height-i); scan_lines = (i+tile_height-1 < height) ? tile_height : (height-i);
/* Get source pixel regions */ /* Get source pixel regions */
for (j = 0; j < num_images; j++) for (j = 0; j < num_images; j++)
gimp_pixel_rgn_get_rect (&(pixel_rgn_src[j]), src[j], 0, i, gimp_pixel_rgn_get_rect (&(pixel_rgn_src[j]), src[j], 0, i,
width, scan_lines); width, scan_lines);
/* Do the composition */ /* Do the composition */
compose_dsc[compose_idx].compose_fun (src,incr_src,width*tile_height,dst); compose_dsc[compose_idx].compose_fun (src,incr_src,width*tile_height,dst);
/* Set destination pixel region */ /* Set destination pixel region */
gimp_pixel_rgn_set_rect (&pixel_rgn_dst, dst, 0, i, width, scan_lines); gimp_pixel_rgn_set_rect (&pixel_rgn_dst, dst, 0, i, width, scan_lines);
i += scan_lines; i += scan_lines;
if (run_mode != RUN_NONINTERACTIVE) if (run_mode != RUN_NONINTERACTIVE)
gimp_progress_update (((double)i) / (double)height); gimp_progress_update (((double)i) / (double)height);
} }
for (j = 0; j < num_images; j++) for (j = 0; j < num_images; j++)
{ {
g_free (src[j]); g_free (src[j]);
gimp_drawable_flush (drawable_src[j]); gimp_drawable_flush (drawable_src[j]);
gimp_drawable_detach (drawable_src[j]); gimp_drawable_detach (drawable_src[j]);
} }
g_free (dst); g_free (dst);
gimp_drawable_flush (drawable_dst); gimp_drawable_flush (drawable_dst);
gimp_drawable_detach (drawable_dst); gimp_drawable_detach (drawable_dst);
return image_ID_dst; return image_ID_dst;
} }
/* Create an image. Sets layer_ID, drawable and rgn. Returns image_ID */ /* Create an image. Sets layer_ID, drawable and rgn. Returns image_ID */
static gint32 static gint32
create_new_image (char *filename, create_new_image (char *filename,
guint width, guint width,
guint height, guint height,
GDrawableType gdtype, GDrawableType gdtype,
gint32 *layer_ID, gint32 *layer_ID,
GDrawable **drawable, GDrawable **drawable,
GPixelRgn *pixel_rgn) GPixelRgn *pixel_rgn)
{
{gint32 image_ID; gint32 image_ID;
GImageType gitype; GImageType gitype;
if ((gdtype == GRAY_IMAGE) || (gdtype == GRAYA_IMAGE)) if ((gdtype == GRAY_IMAGE) || (gdtype == GRAYA_IMAGE))
gitype = GRAY; gitype = GRAY;
else if ((gdtype == INDEXED_IMAGE) || (gdtype == INDEXEDA_IMAGE)) else if ((gdtype == INDEXED_IMAGE) || (gdtype == INDEXEDA_IMAGE))
gitype = INDEXED; gitype = INDEXED;
else else
gitype = RGB; gitype = RGB;
image_ID = gimp_image_new (width, height, gitype); image_ID = gimp_image_new (width, height, gitype);
gimp_image_set_filename (image_ID, filename); gimp_image_set_filename (image_ID, filename);
*layer_ID = gimp_layer_new (image_ID, _("Background"), width, height, *layer_ID = gimp_layer_new (image_ID, _("Background"), width, height,
gdtype, 100, NORMAL_MODE); gdtype, 100, NORMAL_MODE);
gimp_image_add_layer (image_ID, *layer_ID, 0); gimp_image_add_layer (image_ID, *layer_ID, 0);
*drawable = gimp_drawable_get (*layer_ID); *drawable = gimp_drawable_get (*layer_ID);
gimp_pixel_rgn_init (pixel_rgn, *drawable, 0, 0, (*drawable)->width, gimp_pixel_rgn_init (pixel_rgn, *drawable, 0, 0, (*drawable)->width,
(*drawable)->height, TRUE, FALSE); (*drawable)->height, TRUE, FALSE);
return (image_ID); return (image_ID);
} }
/* Compare two strings ignoring case (could also be done by strcasecmp() */ /* Compare two strings ignoring case (could also be done by strcasecmp() */
/* but is it available everywhere ?) */ /* but is it available everywhere ?) */
static int cmp_icase (char *s1, char *s2) static int
cmp_icase (char *s1,
{int c1, c2; char *s2)
{
int c1, c2;
c1 = toupper (*s1); c2 = toupper (*s2); c1 = toupper (*s1); c2 = toupper (*s2);
while (*s1 && *s2) while (*s1 && *s2)
{ {
if (c1 != c2) return (c2 - c1); if (c1 != c2) return (c2 - c1);
c1 = toupper (*(++s1)); c2 = toupper (*(++s2)); c1 = toupper (*(++s1)); c2 = toupper (*(++s2));
} }
return (c2 - c1); return (c2 - c1);
} }
static void static void
compose_rgb (unsigned char **src, compose_rgb (unsigned char **src,
int *incr_src, int *incr_src,
int numpix, int numpix,
unsigned char *dst) unsigned char *dst)
{
{register unsigned char *red_src = src[0]; register unsigned char *red_src = src[0];
register unsigned char *green_src = src[1]; register unsigned char *green_src = src[1];
register unsigned char *blue_src = src[2]; register unsigned char *blue_src = src[2];
register unsigned char *rgb_dst = dst; register unsigned char *rgb_dst = dst;
register int count = numpix; register int count = numpix;
int red_incr = incr_src[0], green_incr = incr_src[1], blue_incr = incr_src[2]; int red_incr = incr_src[0], green_incr = incr_src[1], blue_incr = incr_src[2];
if ((red_incr == 1) && (green_incr == 1) && (blue_incr == 1)) if ((red_incr == 1) && (green_incr == 1) && (blue_incr == 1))
{ {
while (count-- > 0) while (count-- > 0)
{ {
*(rgb_dst++) = *(red_src++); *(rgb_dst++) = *(red_src++);
*(rgb_dst++) = *(green_src++); *(rgb_dst++) = *(green_src++);
*(rgb_dst++) = *(blue_src++); *(rgb_dst++) = *(blue_src++);
} }
} }
else else
{ {
while (count-- > 0) while (count-- > 0)
{ {
*(rgb_dst++) = *red_src; red_src += red_incr; *(rgb_dst++) = *red_src; red_src += red_incr;
*(rgb_dst++) = *green_src; green_src += green_incr; *(rgb_dst++) = *green_src; green_src += green_incr;
*(rgb_dst++) = *blue_src; blue_src += blue_incr; *(rgb_dst++) = *blue_src; blue_src += blue_incr;
} }
} }
} }
static void static void
compose_rgba (unsigned char **src, compose_rgba (unsigned char **src,
int *incr_src, int *incr_src,
int numpix, int numpix,
unsigned char *dst) unsigned char *dst)
{
{register unsigned char *red_src = src[0]; register unsigned char *red_src = src[0];
register unsigned char *green_src = src[1]; register unsigned char *green_src = src[1];
register unsigned char *blue_src = src[2]; register unsigned char *blue_src = src[2];
register unsigned char *alpha_src = src[3]; register unsigned char *alpha_src = src[3];
register unsigned char *rgb_dst = dst; register unsigned char *rgb_dst = dst;
register int count = numpix; register int count = numpix;
int red_incr = incr_src[0], green_incr = incr_src[1], int red_incr = incr_src[0], green_incr = incr_src[1],
blue_incr = incr_src[2], alpha_incr = incr_src[3]; blue_incr = incr_src[2], alpha_incr = incr_src[3];
if ( (red_incr == 1) && (green_incr == 1) && (blue_incr == 1) if ( (red_incr == 1) && (green_incr == 1) && (blue_incr == 1)
&& (alpha_incr == 1)) && (alpha_incr == 1))
{ {
while (count-- > 0) while (count-- > 0)
{ {
*(rgb_dst++) = *(red_src++); *(rgb_dst++) = *(red_src++);
*(rgb_dst++) = *(green_src++); *(rgb_dst++) = *(green_src++);
*(rgb_dst++) = *(blue_src++); *(rgb_dst++) = *(blue_src++);
*(rgb_dst++) = *(alpha_src++); *(rgb_dst++) = *(alpha_src++);
} }
} }
else else
{ {
while (count-- > 0) while (count-- > 0)
{ {
*(rgb_dst++) = *red_src; red_src += red_incr; *(rgb_dst++) = *red_src; red_src += red_incr;
*(rgb_dst++) = *green_src; green_src += green_incr; *(rgb_dst++) = *green_src; green_src += green_incr;
*(rgb_dst++) = *blue_src; blue_src += blue_incr; *(rgb_dst++) = *blue_src; blue_src += blue_incr;
*(rgb_dst++) = *alpha_src; alpha_src += alpha_incr; *(rgb_dst++) = *alpha_src; alpha_src += alpha_incr;
} }
} }
} }
static void static void
compose_hsv (unsigned char **src, compose_hsv (unsigned char **src,
int *incr_src, int *incr_src,
int numpix, int numpix,
unsigned char *dst) unsigned char *dst)
{
{register unsigned char *hue_src = src[0]; register unsigned char *hue_src = src[0];
register unsigned char *sat_src = src[1]; register unsigned char *sat_src = src[1];
register unsigned char *val_src = src[2]; register unsigned char *val_src = src[2];
register unsigned char *rgb_dst = dst; register unsigned char *rgb_dst = dst;
register int count = numpix; register int count = numpix;
int hue_incr = incr_src[0], sat_incr = incr_src[1], val_incr = incr_src[2]; int hue_incr = incr_src[0], sat_incr = incr_src[1], val_incr = incr_src[2];
while (count-- > 0) while (count-- > 0)
{ {
hsv_to_rgb (hue_src, sat_src, val_src, rgb_dst); hsv_to_rgb (hue_src, sat_src, val_src, rgb_dst);
rgb_dst += 3; rgb_dst += 3;
hue_src += hue_incr; hue_src += hue_incr;
sat_src += sat_incr; sat_src += sat_incr;
val_src += val_incr; val_src += val_incr;
} }
} }
static void static void
compose_cmy (unsigned char **src, compose_cmy (unsigned char **src,
int *incr_src, int *incr_src,
int numpix, int numpix,
unsigned char *dst) unsigned char *dst)
{
{register unsigned char *cyan_src = src[0]; register unsigned char *cyan_src = src[0];
register unsigned char *magenta_src = src[1]; register unsigned char *magenta_src = src[1];
register unsigned char *yellow_src = src[2]; register unsigned char *yellow_src = src[2];
register unsigned char *rgb_dst = dst; register unsigned char *rgb_dst = dst;
register int count = numpix; register int count = numpix;
int cyan_incr = incr_src[0], magenta_incr = incr_src[1], int cyan_incr = incr_src[0], magenta_incr = incr_src[1],
yellow_incr = incr_src[2]; yellow_incr = incr_src[2];
if ( (cyan_incr == 1) && (magenta_incr == 1) && (yellow_incr == 1)) if ((cyan_incr == 1) && (magenta_incr == 1) && (yellow_incr == 1))
{ {
while (count-- > 0) while (count-- > 0)
{ {
*(rgb_dst++) = 255 - *(cyan_src++); *(rgb_dst++) = 255 - *(cyan_src++);
*(rgb_dst++) = 255 - *(magenta_src++); *(rgb_dst++) = 255 - *(magenta_src++);
*(rgb_dst++) = 255 - *(yellow_src++); *(rgb_dst++) = 255 - *(yellow_src++);
} }
} }
else else
{ {
while (count-- > 0) while (count-- > 0)
{ {
*(rgb_dst++) = 255 - *cyan_src; *(rgb_dst++) = 255 - *cyan_src;
*(rgb_dst++) = 255 - *magenta_src; *(rgb_dst++) = 255 - *magenta_src;
*(rgb_dst++) = 255 - *yellow_src; *(rgb_dst++) = 255 - *yellow_src;
cyan_src += cyan_incr; cyan_src += cyan_incr;
magenta_src += magenta_incr; magenta_src += magenta_incr;
yellow_src += yellow_incr; yellow_src += yellow_incr;
} }
} }
} }
static void static void
compose_cmyk (unsigned char **src, compose_cmyk (unsigned char **src,
int *incr_src, int *incr_src,
int numpix, int numpix,
unsigned char *dst) unsigned char *dst)
{
{register unsigned char *cyan_src = src[0]; register unsigned char *cyan_src = src[0];
register unsigned char *magenta_src = src[1]; register unsigned char *magenta_src = src[1];
register unsigned char *yellow_src = src[2]; register unsigned char *yellow_src = src[2];
register unsigned char *black_src = src[3]; register unsigned char *black_src = src[3];
register unsigned char *rgb_dst = dst; register unsigned char *rgb_dst = dst;
register int count = numpix; register int count = numpix;
int cyan, magenta, yellow, black; int cyan, magenta, yellow, black;
int cyan_incr = incr_src[0], magenta_incr = incr_src[1], int cyan_incr = incr_src[0], magenta_incr = incr_src[1],
yellow_incr = incr_src[2], black_incr = incr_src[3]; yellow_incr = incr_src[2], black_incr = incr_src[3];
while (count-- > 0) while (count-- > 0)
{ {
black = (int)*black_src; black = (int)*black_src;
if (black) if (black)
{ {
cyan = (int)*cyan_src; cyan = (int)*cyan_src;
magenta = (int)*magenta_src; magenta = (int)*magenta_src;
yellow = (int)*yellow_src; yellow = (int)*yellow_src;
cyan += black; if (cyan > 255) cyan = 255; cyan += black; if (cyan > 255) cyan = 255;
magenta += black; if (magenta > 255) magenta = 255; magenta += black; if (magenta > 255) magenta = 255;
yellow += black; if (yellow > 255) yellow = 255; yellow += black; if (yellow > 255) yellow = 255;
*(rgb_dst++) = 255 - cyan; *(rgb_dst++) = 255 - cyan;
*(rgb_dst++) = 255 - magenta; *(rgb_dst++) = 255 - magenta;
*(rgb_dst++) = 255 - yellow; *(rgb_dst++) = 255 - yellow;
} }
else else
{ {
*(rgb_dst++) = 255 - *cyan_src; *(rgb_dst++) = 255 - *cyan_src;
*(rgb_dst++) = 255 - *magenta_src; *(rgb_dst++) = 255 - *magenta_src;
*(rgb_dst++) = 255 - *yellow_src; *(rgb_dst++) = 255 - *yellow_src;
} }
cyan_src += cyan_incr; cyan_src += cyan_incr;
magenta_src += magenta_incr; magenta_src += magenta_incr;
yellow_src += yellow_incr; yellow_src += yellow_incr;
black_src += black_incr; black_src += black_incr;
} }
} }
static gint static gint
compose_dialog (char *compose_type, compose_dialog (char *compose_type,
gint32 drawable_ID) gint32 drawable_ID)
{ {
GtkWidget *dlg; GtkWidget *dlg;
GtkWidget *button; GtkWidget *button;
@ -935,84 +938,95 @@ hsv_to_rgb (unsigned char *h,
unsigned char *s, unsigned char *s,
unsigned char *v, unsigned char *v,
unsigned char *rgb) unsigned char *rgb)
{
{double hue, sat, val; double hue, sat, val;
double f, p, q, t; double f, p, q, t;
int red, green, blue; int red, green, blue;
if (*s == 0) if (*s == 0)
{ {
rgb[0] = rgb[1] = rgb[2] = *v; rgb[0] = rgb[1] = rgb[2] = *v;
} }
else else
{ {
hue = *h * 6.0 / 255.0; hue = *h * 6.0 / 255.0;
sat = *s / 255.0; sat = *s / 255.0;
val = *v / 255.0; val = *v / 255.0;
f = hue - (int) hue;
p = val * (1.0 - sat);
q = val * (1.0 - (sat * f));
t = val * (1.0 - (sat * (1.0 - f)));
switch ((int) hue)
{
case 0:
red = (int)(val * 255.0);
green = (int)(t * 255.0);
blue = (int)(p * 255.0);
break;
case 1:
red = (int)(q * 255.0);
green = (int)(val * 255.0);
blue = (int)(p * 255.0);
break;
case 2:
red = (int)(p * 255.0);
green = (int)(val * 255.0);
blue = (int)(t * 255.0);
break;
case 3:
red = (int)(p * 255.0);
green = (int)(q * 255.0);
blue = (int)(val * 255.0);
break;
case 4:
red = (int)(t * 255.0);
green = (int)(p * 255.0);
blue = (int)(val * 255.0);
break;
case 5:
red = (int)(val * 255.0);
green = (int)(p * 255.0);
blue = (int)(q * 255.0);
break;
default:
red = 0;
green = 0;
blue = 0;
break;
}
f = hue - (int) hue; if (red < 0)
p = val * (1.0 - sat); red = 0;
q = val * (1.0 - (sat * f)); else if (red > 255)
t = val * (1.0 - (sat * (1.0 - f))); red = 255;
if (green < 0)
green = 0;
else if (green > 255)
green = 255;
if (blue < 0)
blue = 0;
else if (blue > 255)
blue = 255;
switch ((int) hue) rgb[0] = (unsigned char)red;
{ rgb[1] = (unsigned char)green;
case 0: rgb[2] = (unsigned char)blue;
red = (int)(val * 255.0); }
green = (int)(t * 255.0);
blue = (int)(p * 255.0);
break;
case 1:
red = (int)(q * 255.0);
green = (int)(val * 255.0);
blue = (int)(p * 255.0);
break;
case 2:
red = (int)(p * 255.0);
green = (int)(val * 255.0);
blue = (int)(t * 255.0);
break;
case 3:
red = (int)(p * 255.0);
green = (int)(q * 255.0);
blue = (int)(val * 255.0);
break;
case 4:
red = (int)(t * 255.0);
green = (int)(p * 255.0);
blue = (int)(val * 255.0);
break;
case 5:
red = (int)(val * 255.0);
green = (int)(p * 255.0);
blue = (int)(q * 255.0);
break;
default:
red = 0;
green = 0;
blue = 0;
break;
}
if (red < 0) red = 0; else if (red > 255) red = 255;
if (green < 0) green = 0; else if (green > 255) green = 255;
if (blue < 0) blue = 0; else if (blue > 255) blue = 255;
rgb[0] = (unsigned char)red;
rgb[1] = (unsigned char)green;
rgb[2] = (unsigned char)blue;
}
} }
/* Compose interface functions */ /* Compose interface functions */
static gint static gint
check_gray (gint32 image_id, check_gray (gint32 image_id,
gint32 drawable_id, gint32 drawable_id,
gpointer data) gpointer data)
{ {
return ( (gimp_image_base_type (image_id) == GRAY) return ((gimp_image_base_type (image_id) == GRAY)
&& (gimp_image_width (image_id) == composeint.width) && (gimp_image_width (image_id) == composeint.width)
&& (gimp_image_height (image_id) == composeint.height)); && (gimp_image_height (image_id) == composeint.height));
} }
@ -1020,7 +1034,7 @@ static void
image_menu_callback (gint32 id, image_menu_callback (gint32 id,
gpointer data) gpointer data)
{ {
*(gint32 *)data = id; *(gint32 *)data = id;
} }
@ -1044,13 +1058,13 @@ compose_ok_callback (GtkWidget *widget,
composevals.compose_ID[j] = composeint.select_ID[j]; composevals.compose_ID[j] = composeint.select_ID[j];
for (j = 0; j < MAX_COMPOSE_TYPES; j++) for (j = 0; j < MAX_COMPOSE_TYPES; j++)
{
if (composeint.compose_flag[j])
{ {
strcpy (composevals.compose_type, compose_dsc[j].compose_type); if (composeint.compose_flag[j])
break; {
strcpy (composevals.compose_type, compose_dsc[j].compose_type);
break;
}
} }
}
} }
@ -1065,19 +1079,27 @@ compose_type_toggle_update (GtkWidget *widget,
toggle_val = (gint *) data; toggle_val = (gint *) data;
if (GTK_TOGGLE_BUTTON (widget)->active) if (GTK_TOGGLE_BUTTON (widget)->active)
{ {
*toggle_val = TRUE; *toggle_val = TRUE;
compose_idx = toggle_val - &(composeint.compose_flag[0]); compose_idx = toggle_val - &(composeint.compose_flag[0]);
for (j = 0; j < MAX_COMPOSE_IMAGES; j++) for (j = 0; j < MAX_COMPOSE_IMAGES; j++)
gtk_label_set_text (GTK_LABEL (composeint.channel_label[j]), gtk_label_set_text (GTK_LABEL (composeint.channel_label[j]),
compose_dsc[compose_idx].channel_name[j]); compose_dsc[compose_idx].channel_name[j]);
/* Set sensitivity of last label */ /* Set sensitivity of last label */
sensitive = (strcmp (compose_dsc[compose_idx].channel_name[3], sensitive = (strcmp (compose_dsc[compose_idx].channel_name[3],
CHNL_NA) != 0); CHNL_NA) != 0);
gtk_widget_set_sensitive (composeint.channel_label[3], sensitive); gtk_widget_set_sensitive (composeint.channel_label[3], sensitive);
gtk_widget_set_sensitive (composeint.channel_menu[3], sensitive); gtk_widget_set_sensitive (composeint.channel_menu[3], sensitive);
} }
else else
*toggle_val = FALSE; *toggle_val = FALSE;
} }

857
plug-ins/common/decompose.c
View File

@ -228,10 +228,10 @@ query ()
static void show_message (const char *message) static void show_message (const char *message)
{ {
if (run_mode == RUN_INTERACTIVE) if (run_mode == RUN_INTERACTIVE)
g_message (message); gimp_message (message);
else else
printf ("%s\n", message); printf ("%s\n", message);
} }
@ -259,10 +259,10 @@ run (char *name,
values[0].type = PARAM_STATUS; values[0].type = PARAM_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
for (j = 0; j < MAX_EXTRACT_IMAGES; j++) for (j = 0; j < MAX_EXTRACT_IMAGES; j++)
{ {
values[j+1].type = PARAM_IMAGE; values[j+1].type = PARAM_IMAGE;
values[j+1].data.d_int32 = -1; values[j+1].data.d_int32 = -1;
} }
switch (run_mode) switch (run_mode)
{ {
@ -299,39 +299,39 @@ run (char *name,
/* Make sure that the drawable is RGB color */ /* Make sure that the drawable is RGB color */
drawable_type = gimp_drawable_type (param[2].data.d_drawable); drawable_type = gimp_drawable_type (param[2].data.d_drawable);
if ((drawable_type != RGB_IMAGE) && (drawable_type != RGBA_IMAGE)) if ((drawable_type != RGB_IMAGE) && (drawable_type != RGBA_IMAGE))
{ {
show_message (_("plug_in_decompose: Can only work on RGB*_IMAGE")); show_message (_("plug_in_decompose: Can only work on RGB*_IMAGE"));
status = STATUS_CALLING_ERROR; status = STATUS_CALLING_ERROR;
} }
if (status == STATUS_SUCCESS) if (status == STATUS_SUCCESS)
{ {
if (run_mode != RUN_NONINTERACTIVE) if (run_mode != RUN_NONINTERACTIVE)
gimp_progress_init (_("Decomposing...")); gimp_progress_init (_("Decomposing..."));
num_images = decompose (param[1].data.d_image, param[2].data.d_drawable, num_images = decompose (param[1].data.d_image, param[2].data.d_drawable,
decovals.extract_type, image_ID_extract); decovals.extract_type, image_ID_extract);
if (num_images <= 0) if (num_images <= 0)
{ {
status = STATUS_EXECUTION_ERROR; status = STATUS_EXECUTION_ERROR;
} }
else else
{ {
for (j = 0; j < num_images; j++) for (j = 0; j < num_images; j++)
{ {
values[j+1].data.d_int32 = image_ID_extract[j]; values[j+1].data.d_int32 = image_ID_extract[j];
gimp_image_enable_undo (image_ID_extract[j]); gimp_image_enable_undo (image_ID_extract[j]);
gimp_image_clean_all (image_ID_extract[j]); gimp_image_clean_all (image_ID_extract[j]);
if (run_mode != RUN_NONINTERACTIVE) if (run_mode != RUN_NONINTERACTIVE)
gimp_display_new (image_ID_extract[j]); gimp_display_new (image_ID_extract[j]);
} }
/* Store data */ /* Store data */
if (run_mode == RUN_INTERACTIVE) if (run_mode == RUN_INTERACTIVE)
gimp_set_data ("plug_in_decompose", &decovals, sizeof (DecoVals)); gimp_set_data ("plug_in_decompose", &decovals, sizeof (DecoVals));
} }
} }
values[0].data.d_status = status; values[0].data.d_status = status;
} }
@ -341,11 +341,10 @@ run (char *name,
On failure, -1 is returned. On failure, -1 is returned.
*/ */
static gint32 static gint32
decompose (gint32 image_ID, decompose (gint32 image_ID,
gint32 drawable_ID, gint32 drawable_ID,
char *extract_type, char *extract_type,
gint32 *image_ID_dst) gint32 *image_ID_dst)
{ {
int i, j, extract_idx, scan_lines; int i, j, extract_idx, scan_lines;
int height, width, tile_height, num_images; int height, width, tile_height, num_images;
@ -358,29 +357,29 @@ decompose (gint32 image_ID,
extract_idx = -1; /* Search extract type */ extract_idx = -1; /* Search extract type */
for (j = 0; j < NUM_EXTRACT_TYPES; j++) for (j = 0; j < NUM_EXTRACT_TYPES; j++)
{
if (cmp_icase (extract_type, extract[j].type) == 0)
{ {
extract_idx = j; if (cmp_icase (extract_type, extract[j].type) == 0)
break; {
extract_idx = j;
break;
}
} }
}
if (extract_idx < 0) return (-1); if (extract_idx < 0) return (-1);
/* Check structure of source image */ /* Check structure of source image */
drawable_src = gimp_drawable_get (drawable_ID); drawable_src = gimp_drawable_get (drawable_ID);
if (drawable_src->bpp < 3) if (drawable_src->bpp < 3)
{ {
show_message (_("decompose: not an RGB image")); show_message (_("decompose: not an RGB image"));
return (-1); return (-1);
} }
if ( (extract[extract_idx].extract_fun == extract_alpha) if ((extract[extract_idx].extract_fun == extract_alpha) &&
&& (!gimp_drawable_has_alpha (drawable_ID))) (!gimp_drawable_has_alpha (drawable_ID)))
{ {
show_message (_("decompose: No alpha channel available")); show_message (_("decompose: No alpha channel available"));
return (-1); return (-1);
} }
width = drawable_src->width; width = drawable_src->width;
height = drawable_src->height; height = drawable_src->height;
@ -393,106 +392,113 @@ decompose (gint32 image_ID,
/* Create all new gray images */ /* Create all new gray images */
num_images = extract[extract_idx].num_images; num_images = extract[extract_idx].num_images;
if (num_images > MAX_EXTRACT_IMAGES) num_images = MAX_EXTRACT_IMAGES; if (num_images > MAX_EXTRACT_IMAGES)
num_images = MAX_EXTRACT_IMAGES;
for (j = 0; j < num_images; j++) for (j = 0; j < num_images; j++)
{
sprintf (filename, "%s-%s", gimp_image_get_filename (image_ID),
extract[extract_idx].channel_name[j]);
image_ID_dst[j] = create_new_image (filename, width, height, GRAY,
layer_ID_dst+j, drawable_dst+j, pixel_rgn_dst+j);
dst[j] = (unsigned char *)g_malloc (tile_height * width);
}
if (dst[num_images-1] == NULL)
{
show_message (_("decompose: out of memory"));
for (j = 0; j < num_images; j++)
{ {
if (dst[j] != NULL) g_free (dst[j]); sprintf (filename, "%s-%s", gimp_image_get_filename (image_ID),
extract[extract_idx].channel_name[j]);
image_ID_dst[j] = create_new_image (filename, width, height, GRAY,
layer_ID_dst+j, drawable_dst+j, pixel_rgn_dst+j);
dst[j] = (unsigned char *)g_malloc (tile_height * width);
} }
return (-1); if (dst[num_images-1] == NULL)
} {
show_message (_("decompose: out of memory"));
for (j = 0; j < num_images; j++)
{
if (dst[j] != NULL) g_free (dst[j]);
}
return (-1);
}
i = 0; i = 0;
while (i < height) while (i < height)
{ {
/* Get source pixel region */ /* Get source pixel region */
scan_lines = (i+tile_height-1 < height) ? tile_height : (height-i); 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); gimp_pixel_rgn_get_rect (&pixel_rgn_src, src, 0, i, width, scan_lines);
/* Extract the channel information */ /* Extract the channel information */
extract[extract_idx].extract_fun (src, drawable_src->bpp, scan_lines*width, extract[extract_idx].extract_fun (src, drawable_src->bpp, scan_lines*width,
dst); dst);
/* Set destination pixel regions */ /* Set destination pixel regions */
for (j = 0; j < num_images; j++) for (j = 0; j < num_images; j++)
gimp_pixel_rgn_set_rect (&(pixel_rgn_dst[j]), dst[j], 0, i, width, gimp_pixel_rgn_set_rect (&(pixel_rgn_dst[j]), dst[j], 0, i, width,
scan_lines); scan_lines);
i += scan_lines; i += scan_lines;
if (run_mode != RUN_NONINTERACTIVE) if (run_mode != RUN_NONINTERACTIVE)
gimp_progress_update (((double)i) / (double)height); gimp_progress_update (((double)i) / (double)height);
} }
g_free (src); g_free (src);
for (j = 0; j < num_images; j++) for (j = 0; j < num_images; j++)
{ {
gimp_drawable_flush (drawable_dst[j]); gimp_drawable_flush (drawable_dst[j]);
gimp_drawable_detach (drawable_dst[j]); gimp_drawable_detach (drawable_dst[j]);
g_free (dst[j]); g_free (dst[j]);
} }
gimp_drawable_flush (drawable_src); gimp_drawable_flush (drawable_src);
gimp_drawable_detach (drawable_src); gimp_drawable_detach (drawable_src);
return (num_images); return (num_images);
} }
/* Create an image. Sets layer_ID, drawable and rgn. Returns image_ID */ /* Create an image. Sets layer_ID, drawable and rgn. Returns image_ID */
static gint32 static gint32
create_new_image (char *filename, create_new_image (char *filename,
guint width, guint width,
guint height, guint height,
GImageType type, GImageType type,
gint32 *layer_ID, gint32 *layer_ID,
GDrawable **drawable, GDrawable **drawable,
GPixelRgn *pixel_rgn) GPixelRgn *pixel_rgn)
{
{gint32 image_ID; gint32 image_ID;
GDrawableType gdtype; GDrawableType gdtype;
if (type == GRAY) gdtype = GRAY_IMAGE; if (type == GRAY)
else if (type == INDEXED) gdtype = INDEXED_IMAGE; gdtype = GRAY_IMAGE;
else gdtype = RGB_IMAGE; else if (type == INDEXED)
gdtype = INDEXED_IMAGE;
image_ID = gimp_image_new (width, height, type); else
gimp_image_set_filename (image_ID, filename); gdtype = RGB_IMAGE;
*layer_ID = gimp_layer_new (image_ID, _("Background"), width, height, image_ID = gimp_image_new (width, height, type);
gdtype, 100, NORMAL_MODE); gimp_image_set_filename (image_ID, filename);
gimp_image_add_layer (image_ID, *layer_ID, 0);
*layer_ID = gimp_layer_new (image_ID, _("Background"), width, height,
*drawable = gimp_drawable_get (*layer_ID); gdtype, 100, NORMAL_MODE);
gimp_pixel_rgn_init (pixel_rgn, *drawable, 0, 0, (*drawable)->width, gimp_image_add_layer (image_ID, *layer_ID, 0);
(*drawable)->height, TRUE, FALSE);
*drawable = gimp_drawable_get (*layer_ID);
return (image_ID); gimp_pixel_rgn_init (pixel_rgn, *drawable, 0, 0, (*drawable)->width,
(*drawable)->height, TRUE, FALSE);
return (image_ID);
} }
/* Compare two strings ignoring case (could also be done by strcasecmp() */ /* Compare two strings ignoring case (could also be done by strcasecmp() */
/* but is it available everywhere ?) */ /* but is it available everywhere ?) */
static int cmp_icase (char *s1, char *s2) static int
cmp_icase (char *s1,
{int c1, c2; char *s2)
{
int c1, c2;
c1 = toupper (*s1); c2 = toupper (*s2); c1 = toupper (*s1); c2 = toupper (*s2);
while (*s1 && *s2) while (*s1 && *s2)
{ {
if (c1 != c2) return (c2 - c1); if (c1 != c2)
c1 = toupper (*(++s1)); c2 = toupper (*(++s2)); return (c2 - c1);
} c1 = toupper (*(++s1)); c2 = toupper (*(++s2));
}
return (c2 - c1); return (c2 - c1);
} }
@ -500,9 +506,14 @@ static int cmp_icase (char *s1, char *s2)
/* Convert RGB to HSV. This routine was taken from decompose plug-in /* Convert RGB to HSV. This routine was taken from decompose plug-in
of GIMP V 0.54 and modified a little bit. of GIMP V 0.54 and modified a little bit.
*/ */
static void rgb_to_hsv (unsigned char *r, unsigned char *g, unsigned char *b, static void
unsigned char *h, unsigned char *s, unsigned char *v) rgb_to_hsv (unsigned char *r,
unsigned char *g,
unsigned char *b,
unsigned char *h,
unsigned char *s,
unsigned char *v)
{ {
int red = (int)*r, green = (int)*g, blue = (int)*b; int red = (int)*r, green = (int)*g, blue = (int)*b;
double hue; double hue;
@ -569,317 +580,377 @@ static void rgb_to_hsv (unsigned char *r, unsigned char *g, unsigned char *b,
/* Extract functions */ /* Extract functions */
static void extract_rgb (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_rgb (unsigned char *src,
int bpp,
{register unsigned char *rgb_src = src; int numpix,
register unsigned char *red_dst = dst[0]; unsigned char **dst)
register unsigned char *green_dst = dst[1]; {
register unsigned char *blue_dst = dst[2]; register unsigned char *rgb_src = src;
register int count = numpix, offset = bpp-3; register unsigned char *red_dst = dst[0];
register unsigned char *green_dst = dst[1];
while (count-- > 0) register unsigned char *blue_dst = dst[2];
{ register int count = numpix, offset = bpp-3;
*(red_dst++) = *(rgb_src++);
*(green_dst++) = *(rgb_src++); while (count-- > 0)
*(blue_dst++) = *(rgb_src++); {
rgb_src += offset; *(red_dst++) = *(rgb_src++);
} *(green_dst++) = *(rgb_src++);
*(blue_dst++) = *(rgb_src++);
rgb_src += offset;
}
} }
static void extract_red (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_red (unsigned char *src,
int bpp,
{register unsigned char *rgb_src = src; int numpix,
register unsigned char *red_dst = dst[0]; unsigned char **dst)
register int count = numpix, offset = bpp; {
register unsigned char *rgb_src = src;
while (count-- > 0) register unsigned char *red_dst = dst[0];
{ register int count = numpix, offset = bpp;
*(red_dst++) = *rgb_src;
rgb_src += offset; while (count-- > 0)
} {
*(red_dst++) = *rgb_src;
rgb_src += offset;
}
} }
static void extract_green (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_green (unsigned char *src,
int bpp,
{register unsigned char *rgb_src = src+1; int numpix,
register unsigned char *green_dst = dst[0]; unsigned char **dst)
register int count = numpix, offset = bpp; {
register unsigned char *rgb_src = src+1;
while (count-- > 0) register unsigned char *green_dst = dst[0];
{ register int count = numpix, offset = bpp;
*(green_dst++) = *rgb_src;
rgb_src += offset; while (count-- > 0)
} {
*(green_dst++) = *rgb_src;
rgb_src += offset;
}
} }
static void extract_blue (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_blue (unsigned char *src,
int bpp,
{register unsigned char *rgb_src = src+2; int numpix,
register unsigned char *blue_dst = dst[0]; unsigned char **dst)
register int count = numpix, offset = bpp; {
register unsigned char *rgb_src = src+2;
while (count-- > 0) register unsigned char *blue_dst = dst[0];
{ register int count = numpix, offset = bpp;
*(blue_dst++) = *rgb_src;
rgb_src += offset; while (count-- > 0)
} {
*(blue_dst++) = *rgb_src;
rgb_src += offset;
}
} }
static void extract_alpha (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_alpha (unsigned char *src,
int bpp,
{register unsigned char *rgb_src = src+3; int numpix,
register unsigned char *alpha_dst = dst[0]; unsigned char **dst)
register int count = numpix, offset = bpp; {
register unsigned char *rgb_src = src+3;
while (count-- > 0) register unsigned char *alpha_dst = dst[0];
{ register int count = numpix, offset = bpp;
*(alpha_dst++) = *rgb_src;
rgb_src += offset; while (count-- > 0)
} {
*(alpha_dst++) = *rgb_src;
rgb_src += offset;
}
} }
static void extract_cmy (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_cmy (unsigned char *src,
int bpp,
{register unsigned char *rgb_src = src; int numpix,
register unsigned char *cyan_dst = dst[0]; unsigned char **dst)
register unsigned char *magenta_dst = dst[1]; {
register unsigned char *yellow_dst = dst[2]; register unsigned char *rgb_src = src;
register int count = numpix, offset = bpp-3; register unsigned char *cyan_dst = dst[0];
register unsigned char *magenta_dst = dst[1];
while (count-- > 0) register unsigned char *yellow_dst = dst[2];
{ register int count = numpix, offset = bpp-3;
*(cyan_dst++) = 255 - *(rgb_src++);
*(magenta_dst++) = 255 - *(rgb_src++); while (count-- > 0)
*(yellow_dst++) = 255 - *(rgb_src++); {
rgb_src += offset; *(cyan_dst++) = 255 - *(rgb_src++);
} *(magenta_dst++) = 255 - *(rgb_src++);
*(yellow_dst++) = 255 - *(rgb_src++);
rgb_src += offset;
}
} }
static void extract_hsv (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_hsv (unsigned char *src,
int bpp,
{register unsigned char *rgb_src = src; int numpix,
register unsigned char *hue_dst = dst[0]; unsigned char **dst)
register unsigned char *sat_dst = dst[1]; {
register unsigned char *val_dst = dst[2]; register unsigned char *rgb_src = src;
register int count = numpix, offset = bpp; register unsigned char *hue_dst = dst[0];
register unsigned char *sat_dst = dst[1];
while (count-- > 0) register unsigned char *val_dst = dst[2];
{ register int count = numpix, offset = bpp;
rgb_to_hsv (rgb_src, rgb_src+1, rgb_src+2, hue_dst++, sat_dst++, val_dst++);
rgb_src += offset; while (count-- > 0)
} {
rgb_to_hsv (rgb_src, rgb_src+1, rgb_src+2, hue_dst++, sat_dst++, val_dst++);
rgb_src += offset;
}
} }
static void extract_hue (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_hue (unsigned char *src,
int bpp,
{register unsigned char *rgb_src = src; int numpix,
register unsigned char *hue_dst = dst[0]; unsigned char **dst)
unsigned char dmy; {
unsigned char *dummy = &dmy; register unsigned char *rgb_src = src;
register int count = numpix, offset = bpp; register unsigned char *hue_dst = dst[0];
unsigned char dmy;
while (count-- > 0) unsigned char *dummy = &dmy;
{ register int count = numpix, offset = bpp;
rgb_to_hsv (rgb_src, rgb_src+1, rgb_src+2, hue_dst++, dummy, dummy);
rgb_src += offset; while (count-- > 0)
} {
rgb_to_hsv (rgb_src, rgb_src+1, rgb_src+2, hue_dst++, dummy, dummy);
rgb_src += offset;
}
} }
static void extract_sat (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_sat (unsigned char *src,
int bpp,
{register unsigned char *rgb_src = src; int numpix,
register unsigned char *sat_dst = dst[0]; unsigned char **dst)
unsigned char dmy; {
unsigned char *dummy = &dmy; register unsigned char *rgb_src = src;
register int count = numpix, offset = bpp; register unsigned char *sat_dst = dst[0];
unsigned char dmy;
while (count-- > 0) unsigned char *dummy = &dmy;
{ register int count = numpix, offset = bpp;
rgb_to_hsv (rgb_src, rgb_src+1, rgb_src+2, dummy, sat_dst++, dummy);
rgb_src += offset; while (count-- > 0)
} {
rgb_to_hsv (rgb_src, rgb_src+1, rgb_src+2, dummy, sat_dst++, dummy);
rgb_src += offset;
}
} }
static void extract_val (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_val (unsigned char *src,
int bpp,
{register unsigned char *rgb_src = src; int numpix,
register unsigned char *val_dst = dst[0]; unsigned char **dst)
unsigned char dmy; {
unsigned char *dummy = &dmy; register unsigned char *rgb_src = src;
register int count = numpix, offset = bpp; register unsigned char *val_dst = dst[0];
unsigned char dmy;
while (count-- > 0) unsigned char *dummy = &dmy;
{ register int count = numpix, offset = bpp;
rgb_to_hsv (rgb_src, rgb_src+1, rgb_src+2, dummy, dummy, val_dst++);
rgb_src += offset; while (count-- > 0)
} {
rgb_to_hsv (rgb_src, rgb_src+1, rgb_src+2, dummy, dummy, val_dst++);
rgb_src += offset;
}
} }
static void extract_cyan (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_cyan (unsigned char *src,
int bpp,
{register unsigned char *rgb_src = src; int numpix,
register unsigned char *cyan_dst = dst[0]; unsigned char **dst)
register int count = numpix, offset = bpp-1; {
register unsigned char *rgb_src = src;
while (count-- > 0) register unsigned char *cyan_dst = dst[0];
{ register int count = numpix, offset = bpp-1;
*(cyan_dst++) = 255 - *(rgb_src++);
rgb_src += offset; while (count-- > 0)
} {
*(cyan_dst++) = 255 - *(rgb_src++);
rgb_src += offset;
}
} }
static void extract_magenta (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_magenta (unsigned char *src,
int bpp,
{register unsigned char *rgb_src = src+1; int numpix,
register unsigned char *magenta_dst = dst[0]; unsigned char **dst)
register int count = numpix, offset = bpp-1; {
register unsigned char *rgb_src = src+1;
while (count-- > 0) register unsigned char *magenta_dst = dst[0];
{ register int count = numpix, offset = bpp-1;
*(magenta_dst++) = 255 - *(rgb_src++);
rgb_src += offset; while (count-- > 0)
} {
*(magenta_dst++) = 255 - *(rgb_src++);
rgb_src += offset;
}
} }
static void extract_yellow (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_yellow (unsigned char *src,
int bpp,
{register unsigned char *rgb_src = src+2; int numpix,
register unsigned char *yellow_dst = dst[0]; unsigned char **dst)
register int count = numpix, offset = bpp-1; {
register unsigned char *rgb_src = src+2;
while (count-- > 0) register unsigned char *yellow_dst = dst[0];
{ register int count = numpix, offset = bpp-1;
*(yellow_dst++) = 255 - *(rgb_src++);
rgb_src += offset; while (count-- > 0)
} {
*(yellow_dst++) = 255 - *(rgb_src++);
rgb_src += offset;
}
} }
static void extract_cmyk (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_cmyk (unsigned char *src,
int bpp,
int numpix,
unsigned char **dst)
{register unsigned char *rgb_src = src; {
register unsigned char *cyan_dst = dst[0]; register unsigned char *rgb_src = src;
register unsigned char *magenta_dst = dst[1]; register unsigned char *cyan_dst = dst[0];
register unsigned char *yellow_dst = dst[2]; register unsigned char *magenta_dst = dst[1];
register unsigned char *black_dst = dst[3]; register unsigned char *yellow_dst = dst[2];
register unsigned char k, s; register unsigned char *black_dst = dst[3];
register int count = numpix, offset = bpp-3; register unsigned char k, s;
register int count = numpix, offset = bpp-3;
while (count-- > 0)
{ while (count-- > 0)
*cyan_dst = k = 255 - *(rgb_src++); {
*magenta_dst = s = 255 - *(rgb_src++); *cyan_dst = k = 255 - *(rgb_src++);
if (s < k) k = s; *magenta_dst = s = 255 - *(rgb_src++);
*yellow_dst = s = 255 - *(rgb_src++); if (s < k)
if (s < k) k = s; /* Black intensity is minimum of c, m, y */ k = s;
if (k) *yellow_dst = s = 255 - *(rgb_src++);
{ if (s < k)
*cyan_dst -= k; /* Remove common part of c, m, y */ k = s; /* Black intensity is minimum of c, m, y */
*magenta_dst -= k; if (k)
*yellow_dst -= k; {
} *cyan_dst -= k; /* Remove common part of c, m, y */
cyan_dst++; *magenta_dst -= k;
magenta_dst++; *yellow_dst -= k;
yellow_dst++; }
*(black_dst++) = k; cyan_dst++;
magenta_dst++;
rgb_src += offset; yellow_dst++;
} *(black_dst++) = k;
rgb_src += offset;
}
} }
static void extract_cyank (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_cyank (unsigned char *src,
int bpp,
{register unsigned char *rgb_src = src; int numpix,
register unsigned char *cyan_dst = dst[0]; unsigned char **dst)
register unsigned char s, k; {
register int count = numpix, offset = bpp-3; register unsigned char *rgb_src = src;
register unsigned char *cyan_dst = dst[0];
while (count-- > 0) register unsigned char s, k;
{ register int count = numpix, offset = bpp-3;
*cyan_dst = k = 255 - *(rgb_src++);
s = 255 - *(rgb_src++); /* magenta */ while (count-- > 0)
if (s < k) k = s; {
s = 255 - *(rgb_src++); /* yellow */ *cyan_dst = k = 255 - *(rgb_src++);
if (s < k) k = s; s = 255 - *(rgb_src++); /* magenta */
if (k) *cyan_dst -= k; if (s < k) k = s;
cyan_dst++; s = 255 - *(rgb_src++); /* yellow */
if (s < k) k = s;
rgb_src += offset; if (k) *cyan_dst -= k;
} cyan_dst++;
rgb_src += offset;
}
} }
static void extract_magentak (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_magentak (unsigned char *src,
int bpp,
{register unsigned char *rgb_src = src; int numpix,
register unsigned char *magenta_dst = dst[0]; unsigned char **dst)
register unsigned char s, k; {
register int count = numpix, offset = bpp-3; register unsigned char *rgb_src = src;
register unsigned char *magenta_dst = dst[0];
while (count-- > 0) register unsigned char s, k;
{ register int count = numpix, offset = bpp-3;
k = 255 - *(rgb_src++); /* cyan */
*magenta_dst = s = 255 - *(rgb_src++); /* magenta */ while (count-- > 0)
if (s < k) k = s; {
s = 255 - *(rgb_src++); /* yellow */ k = 255 - *(rgb_src++); /* cyan */
if (s < k) k = s; *magenta_dst = s = 255 - *(rgb_src++); /* magenta */
if (k) *magenta_dst -= k; if (s < k)
magenta_dst++; k = s;
s = 255 - *(rgb_src++); /* yellow */
rgb_src += offset; if (s < k)
} k = s;
if (k)
*magenta_dst -= k;
magenta_dst++;
rgb_src += offset;
}
} }
static void extract_yellowk (unsigned char *src, int bpp, int numpix, static void
unsigned char **dst) extract_yellowk (unsigned char *src,
int bpp,
int numpix,
unsigned char **dst)
{register unsigned char *rgb_src = src; {
register unsigned char *yellow_dst = dst[0]; register unsigned char *rgb_src = src;
register unsigned char s, k; register unsigned char *yellow_dst = dst[0];
register int count = numpix, offset = bpp-3; register unsigned char s, k;
register int count = numpix, offset = bpp-3;
while (count-- > 0)
{ while (count-- > 0)
k = 255 - *(rgb_src++); /* cyan */ {
s = 255 - *(rgb_src++); /* magenta */ k = 255 - *(rgb_src++); /* cyan */
if (s < k) k = s; s = 255 - *(rgb_src++); /* magenta */
*yellow_dst = s = 255 - *(rgb_src++); if (s < k) k = s;
if (s < k) k = s; *yellow_dst = s = 255 - *(rgb_src++);
if (k) *yellow_dst -= k; if (s < k)
yellow_dst++; k = s;
if (k)
rgb_src += offset; *yellow_dst -= k;
} yellow_dst++;
rgb_src += offset;
}
} }