mirror of https://github.com/GNOME/gimp.git
Sven Neumann
parent
ba3f196538
commit
e192fcfe43
|
|
@ -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>
|
||||
|
||||
* plug-ins/common/sunras.c
|
||||
|
|
|
|||
|
|
@ -256,7 +256,7 @@ static void show_message (const char *message)
|
|||
|
||||
{
|
||||
if (run_mode == RUN_INTERACTIVE)
|
||||
g_message (message);
|
||||
gimp_message (message);
|
||||
else
|
||||
printf ("%s\n", message);
|
||||
}
|
||||
|
|
@ -380,396 +380,399 @@ run (char *name,
|
|||
|
||||
/* Compose an image from several gray-images */
|
||||
static gint32
|
||||
compose (char *compose_type,
|
||||
compose (char *compose_type,
|
||||
gint32 *compose_ID,
|
||||
int compose_by_drawable)
|
||||
|
||||
{int width, height, tile_height, scan_lines;
|
||||
int num_images, compose_idx, incr_src[MAX_COMPOSE_IMAGES];
|
||||
int i, j;
|
||||
gint num_layers;
|
||||
gint32 layer_ID_dst, image_ID_dst;
|
||||
unsigned char *src[MAX_COMPOSE_IMAGES], *dst = (unsigned char *)ident;
|
||||
GDrawableType gdtype_dst;
|
||||
GDrawable *drawable_src[MAX_COMPOSE_IMAGES], *drawable_dst;
|
||||
GPixelRgn pixel_rgn_src[MAX_COMPOSE_IMAGES], pixel_rgn_dst;
|
||||
|
||||
int compose_by_drawable)
|
||||
{
|
||||
int width, height, tile_height, scan_lines;
|
||||
int num_images, compose_idx, incr_src[MAX_COMPOSE_IMAGES];
|
||||
int i, j;
|
||||
gint num_layers;
|
||||
gint32 layer_ID_dst, image_ID_dst;
|
||||
unsigned char *src[MAX_COMPOSE_IMAGES], *dst = (unsigned char *)ident;
|
||||
GDrawableType gdtype_dst;
|
||||
GDrawable *drawable_src[MAX_COMPOSE_IMAGES], *drawable_dst;
|
||||
GPixelRgn pixel_rgn_src[MAX_COMPOSE_IMAGES], pixel_rgn_dst;
|
||||
|
||||
/* Search type of composing */
|
||||
compose_idx = -1;
|
||||
for (j = 0; j < MAX_COMPOSE_TYPES; j++)
|
||||
{
|
||||
if (cmp_icase (compose_type, compose_dsc[j].compose_type) == 0)
|
||||
compose_idx = j;
|
||||
}
|
||||
{
|
||||
if (cmp_icase (compose_type, compose_dsc[j].compose_type) == 0)
|
||||
compose_idx = j;
|
||||
}
|
||||
if (compose_idx < 0)
|
||||
return (-1);
|
||||
|
||||
|
||||
num_images = compose_dsc[compose_idx].num_images;
|
||||
tile_height = gimp_tile_height ();
|
||||
|
||||
|
||||
/* Check image sizes */
|
||||
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]))
|
||||
|| (height != (int)gimp_drawable_height (compose_ID[j])))
|
||||
{
|
||||
show_message (_("compose: drawables have different size"));
|
||||
return -1;
|
||||
}
|
||||
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]))
|
||||
|| (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 */
|
||||
{
|
||||
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]))
|
||||
|| (height != (int)gimp_image_height (compose_ID[j])))
|
||||
{
|
||||
show_message (_("compose: images have different size"));
|
||||
return -1;
|
||||
}
|
||||
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]))
|
||||
|| (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 */
|
||||
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"));
|
||||
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 */
|
||||
i = 0;
|
||||
while (i < height)
|
||||
{
|
||||
scan_lines = (i+tile_height-1 < height) ? tile_height : (height-i);
|
||||
|
||||
/* Get source pixel regions */
|
||||
for (j = 0; j < num_images; j++)
|
||||
gimp_pixel_rgn_get_rect (&(pixel_rgn_src[j]), src[j], 0, i,
|
||||
width, scan_lines);
|
||||
|
||||
/* Do the composition */
|
||||
compose_dsc[compose_idx].compose_fun (src,incr_src,width*tile_height,dst);
|
||||
|
||||
/* Set destination pixel region */
|
||||
gimp_pixel_rgn_set_rect (&pixel_rgn_dst, dst, 0, i, width, scan_lines);
|
||||
|
||||
i += scan_lines;
|
||||
|
||||
if (run_mode != RUN_NONINTERACTIVE)
|
||||
gimp_progress_update (((double)i) / (double)height);
|
||||
}
|
||||
|
||||
{
|
||||
scan_lines = (i+tile_height-1 < height) ? tile_height : (height-i);
|
||||
|
||||
/* Get source pixel regions */
|
||||
for (j = 0; j < num_images; j++)
|
||||
gimp_pixel_rgn_get_rect (&(pixel_rgn_src[j]), src[j], 0, i,
|
||||
width, scan_lines);
|
||||
|
||||
/* Do the composition */
|
||||
compose_dsc[compose_idx].compose_fun (src,incr_src,width*tile_height,dst);
|
||||
|
||||
/* Set destination pixel region */
|
||||
gimp_pixel_rgn_set_rect (&pixel_rgn_dst, dst, 0, i, width, scan_lines);
|
||||
|
||||
i += scan_lines;
|
||||
|
||||
if (run_mode != RUN_NONINTERACTIVE)
|
||||
gimp_progress_update (((double)i) / (double)height);
|
||||
}
|
||||
|
||||
for (j = 0; j < num_images; j++)
|
||||
{
|
||||
g_free (src[j]);
|
||||
gimp_drawable_flush (drawable_src[j]);
|
||||
gimp_drawable_detach (drawable_src[j]);
|
||||
}
|
||||
{
|
||||
g_free (src[j]);
|
||||
gimp_drawable_flush (drawable_src[j]);
|
||||
gimp_drawable_detach (drawable_src[j]);
|
||||
}
|
||||
g_free (dst);
|
||||
gimp_drawable_flush (drawable_dst);
|
||||
gimp_drawable_detach (drawable_dst);
|
||||
|
||||
|
||||
return image_ID_dst;
|
||||
}
|
||||
|
||||
|
||||
/* Create an image. Sets layer_ID, drawable and rgn. Returns image_ID */
|
||||
static gint32
|
||||
create_new_image (char *filename,
|
||||
guint width,
|
||||
guint height,
|
||||
GDrawableType gdtype,
|
||||
gint32 *layer_ID,
|
||||
GDrawable **drawable,
|
||||
GPixelRgn *pixel_rgn)
|
||||
|
||||
{gint32 image_ID;
|
||||
GImageType gitype;
|
||||
|
||||
if ((gdtype == GRAY_IMAGE) || (gdtype == GRAYA_IMAGE))
|
||||
gitype = GRAY;
|
||||
else if ((gdtype == INDEXED_IMAGE) || (gdtype == INDEXEDA_IMAGE))
|
||||
gitype = INDEXED;
|
||||
else
|
||||
gitype = RGB;
|
||||
|
||||
image_ID = gimp_image_new (width, height, gitype);
|
||||
gimp_image_set_filename (image_ID, filename);
|
||||
|
||||
*layer_ID = gimp_layer_new (image_ID, _("Background"), width, height,
|
||||
gdtype, 100, 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 (image_ID);
|
||||
create_new_image (char *filename,
|
||||
guint width,
|
||||
guint height,
|
||||
GDrawableType gdtype,
|
||||
gint32 *layer_ID,
|
||||
GDrawable **drawable,
|
||||
GPixelRgn *pixel_rgn)
|
||||
{
|
||||
gint32 image_ID;
|
||||
GImageType gitype;
|
||||
|
||||
if ((gdtype == GRAY_IMAGE) || (gdtype == GRAYA_IMAGE))
|
||||
gitype = GRAY;
|
||||
else if ((gdtype == INDEXED_IMAGE) || (gdtype == INDEXEDA_IMAGE))
|
||||
gitype = INDEXED;
|
||||
else
|
||||
gitype = RGB;
|
||||
|
||||
image_ID = gimp_image_new (width, height, gitype);
|
||||
gimp_image_set_filename (image_ID, filename);
|
||||
|
||||
*layer_ID = gimp_layer_new (image_ID, _("Background"), width, height,
|
||||
gdtype, 100, 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 (image_ID);
|
||||
}
|
||||
|
||||
|
||||
/* Compare two strings ignoring case (could also be done by strcasecmp() */
|
||||
/* but is it available everywhere ?) */
|
||||
static int cmp_icase (char *s1, char *s2)
|
||||
|
||||
{int c1, c2;
|
||||
|
||||
static int
|
||||
cmp_icase (char *s1,
|
||||
char *s2)
|
||||
{
|
||||
int c1, c2;
|
||||
|
||||
c1 = toupper (*s1); c2 = toupper (*s2);
|
||||
while (*s1 && *s2)
|
||||
{
|
||||
if (c1 != c2) return (c2 - c1);
|
||||
c1 = toupper (*(++s1)); c2 = toupper (*(++s2));
|
||||
}
|
||||
{
|
||||
if (c1 != c2) return (c2 - c1);
|
||||
c1 = toupper (*(++s1)); c2 = toupper (*(++s2));
|
||||
}
|
||||
return (c2 - c1);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
compose_rgb (unsigned char **src,
|
||||
int *incr_src,
|
||||
int numpix,
|
||||
unsigned char *dst)
|
||||
|
||||
{register unsigned char *red_src = src[0];
|
||||
register unsigned char *green_src = src[1];
|
||||
register unsigned char *blue_src = src[2];
|
||||
register unsigned char *rgb_dst = dst;
|
||||
register int count = numpix;
|
||||
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))
|
||||
{
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(rgb_dst++) = *(red_src++);
|
||||
*(rgb_dst++) = *(green_src++);
|
||||
*(rgb_dst++) = *(blue_src++);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(rgb_dst++) = *red_src; red_src += red_incr;
|
||||
*(rgb_dst++) = *green_src; green_src += green_incr;
|
||||
*(rgb_dst++) = *blue_src; blue_src += blue_incr;
|
||||
}
|
||||
}
|
||||
int *incr_src,
|
||||
int numpix,
|
||||
unsigned char *dst)
|
||||
{
|
||||
register unsigned char *red_src = src[0];
|
||||
register unsigned char *green_src = src[1];
|
||||
register unsigned char *blue_src = src[2];
|
||||
register unsigned char *rgb_dst = dst;
|
||||
register int count = numpix;
|
||||
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))
|
||||
{
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(rgb_dst++) = *(red_src++);
|
||||
*(rgb_dst++) = *(green_src++);
|
||||
*(rgb_dst++) = *(blue_src++);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(rgb_dst++) = *red_src; red_src += red_incr;
|
||||
*(rgb_dst++) = *green_src; green_src += green_incr;
|
||||
*(rgb_dst++) = *blue_src; blue_src += blue_incr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
compose_rgba (unsigned char **src,
|
||||
int *incr_src,
|
||||
int numpix,
|
||||
unsigned char *dst)
|
||||
|
||||
{register unsigned char *red_src = src[0];
|
||||
register unsigned char *green_src = src[1];
|
||||
register unsigned char *blue_src = src[2];
|
||||
register unsigned char *alpha_src = src[3];
|
||||
register unsigned char *rgb_dst = dst;
|
||||
register int count = numpix;
|
||||
int red_incr = incr_src[0], green_incr = incr_src[1],
|
||||
blue_incr = incr_src[2], alpha_incr = incr_src[3];
|
||||
|
||||
if ( (red_incr == 1) && (green_incr == 1) && (blue_incr == 1)
|
||||
&& (alpha_incr == 1))
|
||||
{
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(rgb_dst++) = *(red_src++);
|
||||
*(rgb_dst++) = *(green_src++);
|
||||
*(rgb_dst++) = *(blue_src++);
|
||||
*(rgb_dst++) = *(alpha_src++);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(rgb_dst++) = *red_src; red_src += red_incr;
|
||||
*(rgb_dst++) = *green_src; green_src += green_incr;
|
||||
*(rgb_dst++) = *blue_src; blue_src += blue_incr;
|
||||
*(rgb_dst++) = *alpha_src; alpha_src += alpha_incr;
|
||||
}
|
||||
}
|
||||
int *incr_src,
|
||||
int numpix,
|
||||
unsigned char *dst)
|
||||
{
|
||||
register unsigned char *red_src = src[0];
|
||||
register unsigned char *green_src = src[1];
|
||||
register unsigned char *blue_src = src[2];
|
||||
register unsigned char *alpha_src = src[3];
|
||||
register unsigned char *rgb_dst = dst;
|
||||
register int count = numpix;
|
||||
int red_incr = incr_src[0], green_incr = incr_src[1],
|
||||
blue_incr = incr_src[2], alpha_incr = incr_src[3];
|
||||
|
||||
if ( (red_incr == 1) && (green_incr == 1) && (blue_incr == 1)
|
||||
&& (alpha_incr == 1))
|
||||
{
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(rgb_dst++) = *(red_src++);
|
||||
*(rgb_dst++) = *(green_src++);
|
||||
*(rgb_dst++) = *(blue_src++);
|
||||
*(rgb_dst++) = *(alpha_src++);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(rgb_dst++) = *red_src; red_src += red_incr;
|
||||
*(rgb_dst++) = *green_src; green_src += green_incr;
|
||||
*(rgb_dst++) = *blue_src; blue_src += blue_incr;
|
||||
*(rgb_dst++) = *alpha_src; alpha_src += alpha_incr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
compose_hsv (unsigned char **src,
|
||||
int *incr_src,
|
||||
int numpix,
|
||||
unsigned char *dst)
|
||||
|
||||
{register unsigned char *hue_src = src[0];
|
||||
register unsigned char *sat_src = src[1];
|
||||
register unsigned char *val_src = src[2];
|
||||
register unsigned char *rgb_dst = dst;
|
||||
register int count = numpix;
|
||||
int hue_incr = incr_src[0], sat_incr = incr_src[1], val_incr = incr_src[2];
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
hsv_to_rgb (hue_src, sat_src, val_src, rgb_dst);
|
||||
rgb_dst += 3;
|
||||
hue_src += hue_incr;
|
||||
sat_src += sat_incr;
|
||||
val_src += val_incr;
|
||||
}
|
||||
int *incr_src,
|
||||
int numpix,
|
||||
unsigned char *dst)
|
||||
{
|
||||
register unsigned char *hue_src = src[0];
|
||||
register unsigned char *sat_src = src[1];
|
||||
register unsigned char *val_src = src[2];
|
||||
register unsigned char *rgb_dst = dst;
|
||||
register int count = numpix;
|
||||
int hue_incr = incr_src[0], sat_incr = incr_src[1], val_incr = incr_src[2];
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
hsv_to_rgb (hue_src, sat_src, val_src, rgb_dst);
|
||||
rgb_dst += 3;
|
||||
hue_src += hue_incr;
|
||||
sat_src += sat_incr;
|
||||
val_src += val_incr;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
compose_cmy (unsigned char **src,
|
||||
int *incr_src,
|
||||
int numpix,
|
||||
unsigned char *dst)
|
||||
|
||||
{register unsigned char *cyan_src = src[0];
|
||||
register unsigned char *magenta_src = src[1];
|
||||
register unsigned char *yellow_src = src[2];
|
||||
register unsigned char *rgb_dst = dst;
|
||||
register int count = numpix;
|
||||
int cyan_incr = incr_src[0], magenta_incr = incr_src[1],
|
||||
yellow_incr = incr_src[2];
|
||||
|
||||
if ( (cyan_incr == 1) && (magenta_incr == 1) && (yellow_incr == 1))
|
||||
{
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(rgb_dst++) = 255 - *(cyan_src++);
|
||||
*(rgb_dst++) = 255 - *(magenta_src++);
|
||||
*(rgb_dst++) = 255 - *(yellow_src++);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(rgb_dst++) = 255 - *cyan_src;
|
||||
*(rgb_dst++) = 255 - *magenta_src;
|
||||
*(rgb_dst++) = 255 - *yellow_src;
|
||||
cyan_src += cyan_incr;
|
||||
magenta_src += magenta_incr;
|
||||
yellow_src += yellow_incr;
|
||||
}
|
||||
}
|
||||
int *incr_src,
|
||||
int numpix,
|
||||
unsigned char *dst)
|
||||
{
|
||||
register unsigned char *cyan_src = src[0];
|
||||
register unsigned char *magenta_src = src[1];
|
||||
register unsigned char *yellow_src = src[2];
|
||||
register unsigned char *rgb_dst = dst;
|
||||
register int count = numpix;
|
||||
int cyan_incr = incr_src[0], magenta_incr = incr_src[1],
|
||||
yellow_incr = incr_src[2];
|
||||
|
||||
if ((cyan_incr == 1) && (magenta_incr == 1) && (yellow_incr == 1))
|
||||
{
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(rgb_dst++) = 255 - *(cyan_src++);
|
||||
*(rgb_dst++) = 255 - *(magenta_src++);
|
||||
*(rgb_dst++) = 255 - *(yellow_src++);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(rgb_dst++) = 255 - *cyan_src;
|
||||
*(rgb_dst++) = 255 - *magenta_src;
|
||||
*(rgb_dst++) = 255 - *yellow_src;
|
||||
cyan_src += cyan_incr;
|
||||
magenta_src += magenta_incr;
|
||||
yellow_src += yellow_incr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
compose_cmyk (unsigned char **src,
|
||||
int *incr_src,
|
||||
int numpix,
|
||||
unsigned char *dst)
|
||||
|
||||
{register unsigned char *cyan_src = src[0];
|
||||
register unsigned char *magenta_src = src[1];
|
||||
register unsigned char *yellow_src = src[2];
|
||||
register unsigned char *black_src = src[3];
|
||||
register unsigned char *rgb_dst = dst;
|
||||
register int count = numpix;
|
||||
int cyan, magenta, yellow, black;
|
||||
int cyan_incr = incr_src[0], magenta_incr = incr_src[1],
|
||||
yellow_incr = incr_src[2], black_incr = incr_src[3];
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
black = (int)*black_src;
|
||||
if (black)
|
||||
{
|
||||
cyan = (int)*cyan_src;
|
||||
magenta = (int)*magenta_src;
|
||||
yellow = (int)*yellow_src;
|
||||
cyan += black; if (cyan > 255) cyan = 255;
|
||||
magenta += black; if (magenta > 255) magenta = 255;
|
||||
yellow += black; if (yellow > 255) yellow = 255;
|
||||
*(rgb_dst++) = 255 - cyan;
|
||||
*(rgb_dst++) = 255 - magenta;
|
||||
*(rgb_dst++) = 255 - yellow;
|
||||
}
|
||||
else
|
||||
{
|
||||
*(rgb_dst++) = 255 - *cyan_src;
|
||||
*(rgb_dst++) = 255 - *magenta_src;
|
||||
*(rgb_dst++) = 255 - *yellow_src;
|
||||
}
|
||||
cyan_src += cyan_incr;
|
||||
magenta_src += magenta_incr;
|
||||
yellow_src += yellow_incr;
|
||||
black_src += black_incr;
|
||||
}
|
||||
int *incr_src,
|
||||
int numpix,
|
||||
unsigned char *dst)
|
||||
{
|
||||
register unsigned char *cyan_src = src[0];
|
||||
register unsigned char *magenta_src = src[1];
|
||||
register unsigned char *yellow_src = src[2];
|
||||
register unsigned char *black_src = src[3];
|
||||
register unsigned char *rgb_dst = dst;
|
||||
register int count = numpix;
|
||||
int cyan, magenta, yellow, black;
|
||||
int cyan_incr = incr_src[0], magenta_incr = incr_src[1],
|
||||
yellow_incr = incr_src[2], black_incr = incr_src[3];
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
black = (int)*black_src;
|
||||
if (black)
|
||||
{
|
||||
cyan = (int)*cyan_src;
|
||||
magenta = (int)*magenta_src;
|
||||
yellow = (int)*yellow_src;
|
||||
cyan += black; if (cyan > 255) cyan = 255;
|
||||
magenta += black; if (magenta > 255) magenta = 255;
|
||||
yellow += black; if (yellow > 255) yellow = 255;
|
||||
*(rgb_dst++) = 255 - cyan;
|
||||
*(rgb_dst++) = 255 - magenta;
|
||||
*(rgb_dst++) = 255 - yellow;
|
||||
}
|
||||
else
|
||||
{
|
||||
*(rgb_dst++) = 255 - *cyan_src;
|
||||
*(rgb_dst++) = 255 - *magenta_src;
|
||||
*(rgb_dst++) = 255 - *yellow_src;
|
||||
}
|
||||
cyan_src += cyan_incr;
|
||||
magenta_src += magenta_incr;
|
||||
yellow_src += yellow_incr;
|
||||
black_src += black_incr;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static gint
|
||||
compose_dialog (char *compose_type,
|
||||
gint32 drawable_ID)
|
||||
compose_dialog (char *compose_type,
|
||||
gint32 drawable_ID)
|
||||
{
|
||||
GtkWidget *dlg;
|
||||
GtkWidget *button;
|
||||
|
|
@ -935,84 +938,95 @@ hsv_to_rgb (unsigned char *h,
|
|||
unsigned char *s,
|
||||
unsigned char *v,
|
||||
unsigned char *rgb)
|
||||
|
||||
{double hue, sat, val;
|
||||
double f, p, q, t;
|
||||
int red, green, blue;
|
||||
|
||||
{
|
||||
double hue, sat, val;
|
||||
double f, p, q, t;
|
||||
int red, green, blue;
|
||||
|
||||
if (*s == 0)
|
||||
{
|
||||
rgb[0] = rgb[1] = rgb[2] = *v;
|
||||
}
|
||||
{
|
||||
rgb[0] = rgb[1] = rgb[2] = *v;
|
||||
}
|
||||
else
|
||||
{
|
||||
hue = *h * 6.0 / 255.0;
|
||||
sat = *s / 255.0;
|
||||
val = *v / 255.0;
|
||||
{
|
||||
hue = *h * 6.0 / 255.0;
|
||||
sat = *s / 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;
|
||||
p = val * (1.0 - sat);
|
||||
q = val * (1.0 - (sat * f));
|
||||
t = val * (1.0 - (sat * (1.0 - f)));
|
||||
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;
|
||||
|
||||
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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
rgb[0] = (unsigned char)red;
|
||||
rgb[1] = (unsigned char)green;
|
||||
rgb[2] = (unsigned char)blue;
|
||||
}
|
||||
}
|
||||
|
||||
/* Compose interface functions */
|
||||
|
||||
static gint
|
||||
check_gray (gint32 image_id,
|
||||
gint32 drawable_id,
|
||||
check_gray (gint32 image_id,
|
||||
gint32 drawable_id,
|
||||
gpointer data)
|
||||
|
||||
{
|
||||
return ( (gimp_image_base_type (image_id) == GRAY)
|
||||
&& (gimp_image_width (image_id) == composeint.width)
|
||||
&& (gimp_image_height (image_id) == composeint.height));
|
||||
return ((gimp_image_base_type (image_id) == GRAY)
|
||||
&& (gimp_image_width (image_id) == composeint.width)
|
||||
&& (gimp_image_height (image_id) == composeint.height));
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1020,7 +1034,7 @@ static void
|
|||
image_menu_callback (gint32 id,
|
||||
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];
|
||||
|
||||
for (j = 0; j < MAX_COMPOSE_TYPES; j++)
|
||||
{
|
||||
if (composeint.compose_flag[j])
|
||||
{
|
||||
strcpy (composevals.compose_type, compose_dsc[j].compose_type);
|
||||
break;
|
||||
if (composeint.compose_flag[j])
|
||||
{
|
||||
strcpy (composevals.compose_type, compose_dsc[j].compose_type);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1065,19 +1079,27 @@ compose_type_toggle_update (GtkWidget *widget,
|
|||
toggle_val = (gint *) data;
|
||||
|
||||
if (GTK_TOGGLE_BUTTON (widget)->active)
|
||||
{
|
||||
*toggle_val = TRUE;
|
||||
compose_idx = toggle_val - &(composeint.compose_flag[0]);
|
||||
for (j = 0; j < MAX_COMPOSE_IMAGES; j++)
|
||||
gtk_label_set_text (GTK_LABEL (composeint.channel_label[j]),
|
||||
compose_dsc[compose_idx].channel_name[j]);
|
||||
|
||||
/* Set sensitivity of last label */
|
||||
sensitive = (strcmp (compose_dsc[compose_idx].channel_name[3],
|
||||
CHNL_NA) != 0);
|
||||
gtk_widget_set_sensitive (composeint.channel_label[3], sensitive);
|
||||
gtk_widget_set_sensitive (composeint.channel_menu[3], sensitive);
|
||||
}
|
||||
{
|
||||
*toggle_val = TRUE;
|
||||
compose_idx = toggle_val - &(composeint.compose_flag[0]);
|
||||
for (j = 0; j < MAX_COMPOSE_IMAGES; j++)
|
||||
gtk_label_set_text (GTK_LABEL (composeint.channel_label[j]),
|
||||
compose_dsc[compose_idx].channel_name[j]);
|
||||
|
||||
/* Set sensitivity of last label */
|
||||
sensitive = (strcmp (compose_dsc[compose_idx].channel_name[3],
|
||||
CHNL_NA) != 0);
|
||||
gtk_widget_set_sensitive (composeint.channel_label[3], sensitive);
|
||||
gtk_widget_set_sensitive (composeint.channel_menu[3], sensitive);
|
||||
}
|
||||
else
|
||||
*toggle_val = FALSE;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -228,10 +228,10 @@ query ()
|
|||
|
||||
static void show_message (const char *message)
|
||||
{
|
||||
if (run_mode == RUN_INTERACTIVE)
|
||||
g_message (message);
|
||||
else
|
||||
printf ("%s\n", message);
|
||||
if (run_mode == RUN_INTERACTIVE)
|
||||
gimp_message (message);
|
||||
else
|
||||
printf ("%s\n", message);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -259,10 +259,10 @@ run (char *name,
|
|||
values[0].type = PARAM_STATUS;
|
||||
values[0].data.d_status = status;
|
||||
for (j = 0; j < MAX_EXTRACT_IMAGES; j++)
|
||||
{
|
||||
values[j+1].type = PARAM_IMAGE;
|
||||
values[j+1].data.d_int32 = -1;
|
||||
}
|
||||
{
|
||||
values[j+1].type = PARAM_IMAGE;
|
||||
values[j+1].data.d_int32 = -1;
|
||||
}
|
||||
|
||||
switch (run_mode)
|
||||
{
|
||||
|
|
@ -299,39 +299,39 @@ run (char *name,
|
|||
/* Make sure that the drawable is RGB color */
|
||||
drawable_type = gimp_drawable_type (param[2].data.d_drawable);
|
||||
if ((drawable_type != RGB_IMAGE) && (drawable_type != RGBA_IMAGE))
|
||||
{
|
||||
show_message (_("plug_in_decompose: Can only work on RGB*_IMAGE"));
|
||||
status = STATUS_CALLING_ERROR;
|
||||
}
|
||||
{
|
||||
show_message (_("plug_in_decompose: Can only work on RGB*_IMAGE"));
|
||||
status = STATUS_CALLING_ERROR;
|
||||
}
|
||||
if (status == STATUS_SUCCESS)
|
||||
{
|
||||
if (run_mode != RUN_NONINTERACTIVE)
|
||||
gimp_progress_init (_("Decomposing..."));
|
||||
|
||||
|
||||
num_images = decompose (param[1].data.d_image, param[2].data.d_drawable,
|
||||
decovals.extract_type, image_ID_extract);
|
||||
|
||||
|
||||
if (num_images <= 0)
|
||||
{
|
||||
status = STATUS_EXECUTION_ERROR;
|
||||
}
|
||||
{
|
||||
status = STATUS_EXECUTION_ERROR;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (j = 0; j < num_images; j++)
|
||||
{
|
||||
values[j+1].data.d_int32 = image_ID_extract[j];
|
||||
gimp_image_enable_undo (image_ID_extract[j]);
|
||||
gimp_image_clean_all (image_ID_extract[j]);
|
||||
if (run_mode != RUN_NONINTERACTIVE)
|
||||
gimp_display_new (image_ID_extract[j]);
|
||||
}
|
||||
|
||||
/* Store data */
|
||||
if (run_mode == RUN_INTERACTIVE)
|
||||
gimp_set_data ("plug_in_decompose", &decovals, sizeof (DecoVals));
|
||||
}
|
||||
{
|
||||
for (j = 0; j < num_images; j++)
|
||||
{
|
||||
values[j+1].data.d_int32 = image_ID_extract[j];
|
||||
gimp_image_enable_undo (image_ID_extract[j]);
|
||||
gimp_image_clean_all (image_ID_extract[j]);
|
||||
if (run_mode != RUN_NONINTERACTIVE)
|
||||
gimp_display_new (image_ID_extract[j]);
|
||||
}
|
||||
|
||||
/* Store data */
|
||||
if (run_mode == RUN_INTERACTIVE)
|
||||
gimp_set_data ("plug_in_decompose", &decovals, sizeof (DecoVals));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
values[0].data.d_status = status;
|
||||
}
|
||||
|
||||
|
|
@ -341,11 +341,10 @@ run (char *name,
|
|||
On failure, -1 is returned.
|
||||
*/
|
||||
static gint32
|
||||
decompose (gint32 image_ID,
|
||||
gint32 drawable_ID,
|
||||
decompose (gint32 image_ID,
|
||||
gint32 drawable_ID,
|
||||
char *extract_type,
|
||||
gint32 *image_ID_dst)
|
||||
|
||||
{
|
||||
int i, j, extract_idx, scan_lines;
|
||||
int height, width, tile_height, num_images;
|
||||
|
|
@ -358,29 +357,29 @@ decompose (gint32 image_ID,
|
|||
|
||||
extract_idx = -1; /* Search extract type */
|
||||
for (j = 0; j < NUM_EXTRACT_TYPES; j++)
|
||||
{
|
||||
if (cmp_icase (extract_type, extract[j].type) == 0)
|
||||
{
|
||||
extract_idx = j;
|
||||
break;
|
||||
if (cmp_icase (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)
|
||||
{
|
||||
show_message (_("decompose: not an RGB image"));
|
||||
return (-1);
|
||||
}
|
||||
if ( (extract[extract_idx].extract_fun == extract_alpha)
|
||||
&& (!gimp_drawable_has_alpha (drawable_ID)))
|
||||
{
|
||||
show_message (_("decompose: No alpha channel available"));
|
||||
return (-1);
|
||||
}
|
||||
|
||||
{
|
||||
show_message (_("decompose: not an RGB image"));
|
||||
return (-1);
|
||||
}
|
||||
if ((extract[extract_idx].extract_fun == extract_alpha) &&
|
||||
(!gimp_drawable_has_alpha (drawable_ID)))
|
||||
{
|
||||
show_message (_("decompose: No alpha channel available"));
|
||||
return (-1);
|
||||
}
|
||||
|
||||
width = drawable_src->width;
|
||||
height = drawable_src->height;
|
||||
|
||||
|
|
@ -393,106 +392,113 @@ decompose (gint32 image_ID,
|
|||
|
||||
/* Create all new gray 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++)
|
||||
{
|
||||
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;
|
||||
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_images; j++)
|
||||
gimp_pixel_rgn_set_rect (&(pixel_rgn_dst[j]), dst[j], 0, i, width,
|
||||
scan_lines);
|
||||
i += scan_lines;
|
||||
|
||||
if (run_mode != RUN_NONINTERACTIVE)
|
||||
gimp_progress_update (((double)i) / (double)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_images; j++)
|
||||
gimp_pixel_rgn_set_rect (&(pixel_rgn_dst[j]), dst[j], 0, i, width,
|
||||
scan_lines);
|
||||
i += scan_lines;
|
||||
|
||||
if (run_mode != RUN_NONINTERACTIVE)
|
||||
gimp_progress_update (((double)i) / (double)height);
|
||||
}
|
||||
g_free (src);
|
||||
for (j = 0; j < num_images; j++)
|
||||
{
|
||||
gimp_drawable_flush (drawable_dst[j]);
|
||||
gimp_drawable_detach (drawable_dst[j]);
|
||||
g_free (dst[j]);
|
||||
}
|
||||
|
||||
{
|
||||
gimp_drawable_flush (drawable_dst[j]);
|
||||
gimp_drawable_detach (drawable_dst[j]);
|
||||
g_free (dst[j]);
|
||||
}
|
||||
|
||||
gimp_drawable_flush (drawable_src);
|
||||
gimp_drawable_detach (drawable_src);
|
||||
|
||||
|
||||
return (num_images);
|
||||
}
|
||||
|
||||
|
||||
/* Create an image. Sets layer_ID, drawable and rgn. Returns image_ID */
|
||||
static gint32
|
||||
create_new_image (char *filename,
|
||||
guint width,
|
||||
guint height,
|
||||
GImageType type,
|
||||
gint32 *layer_ID,
|
||||
GDrawable **drawable,
|
||||
GPixelRgn *pixel_rgn)
|
||||
|
||||
{gint32 image_ID;
|
||||
GDrawableType gdtype;
|
||||
|
||||
if (type == GRAY) gdtype = GRAY_IMAGE;
|
||||
else if (type == INDEXED) gdtype = INDEXED_IMAGE;
|
||||
else gdtype = RGB_IMAGE;
|
||||
|
||||
image_ID = gimp_image_new (width, height, type);
|
||||
gimp_image_set_filename (image_ID, filename);
|
||||
|
||||
*layer_ID = gimp_layer_new (image_ID, _("Background"), width, height,
|
||||
gdtype, 100, 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 (image_ID);
|
||||
create_new_image (char *filename,
|
||||
guint width,
|
||||
guint height,
|
||||
GImageType type,
|
||||
gint32 *layer_ID,
|
||||
GDrawable **drawable,
|
||||
GPixelRgn *pixel_rgn)
|
||||
{
|
||||
gint32 image_ID;
|
||||
GDrawableType gdtype;
|
||||
|
||||
if (type == GRAY)
|
||||
gdtype = GRAY_IMAGE;
|
||||
else if (type == INDEXED)
|
||||
gdtype = INDEXED_IMAGE;
|
||||
else
|
||||
gdtype = RGB_IMAGE;
|
||||
|
||||
image_ID = gimp_image_new (width, height, type);
|
||||
gimp_image_set_filename (image_ID, filename);
|
||||
|
||||
*layer_ID = gimp_layer_new (image_ID, _("Background"), width, height,
|
||||
gdtype, 100, 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 (image_ID);
|
||||
}
|
||||
|
||||
|
||||
/* Compare two strings ignoring case (could also be done by strcasecmp() */
|
||||
/* but is it available everywhere ?) */
|
||||
static int cmp_icase (char *s1, char *s2)
|
||||
|
||||
{int c1, c2;
|
||||
static int
|
||||
cmp_icase (char *s1,
|
||||
char *s2)
|
||||
{
|
||||
int c1, c2;
|
||||
|
||||
c1 = toupper (*s1); c2 = toupper (*s2);
|
||||
while (*s1 && *s2)
|
||||
{
|
||||
if (c1 != c2) return (c2 - c1);
|
||||
c1 = toupper (*(++s1)); c2 = toupper (*(++s2));
|
||||
}
|
||||
{
|
||||
if (c1 != c2)
|
||||
return (c2 - c1);
|
||||
c1 = toupper (*(++s1)); c2 = toupper (*(++s2));
|
||||
}
|
||||
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
|
||||
of GIMP V 0.54 and modified a little bit.
|
||||
*/
|
||||
static void rgb_to_hsv (unsigned char *r, unsigned char *g, unsigned char *b,
|
||||
unsigned char *h, unsigned char *s, unsigned char *v)
|
||||
|
||||
static void
|
||||
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;
|
||||
double hue;
|
||||
|
|
@ -569,317 +580,377 @@ static void rgb_to_hsv (unsigned char *r, unsigned char *g, unsigned char *b,
|
|||
|
||||
/* Extract functions */
|
||||
|
||||
static void extract_rgb (unsigned char *src, int bpp, int numpix,
|
||||
unsigned char **dst)
|
||||
|
||||
{register unsigned char *rgb_src = src;
|
||||
register unsigned char *red_dst = dst[0];
|
||||
register unsigned char *green_dst = dst[1];
|
||||
register unsigned char *blue_dst = dst[2];
|
||||
register int 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_rgb (unsigned char *src,
|
||||
int bpp,
|
||||
int numpix,
|
||||
unsigned char **dst)
|
||||
{
|
||||
register unsigned char *rgb_src = src;
|
||||
register unsigned char *red_dst = dst[0];
|
||||
register unsigned char *green_dst = dst[1];
|
||||
register unsigned char *blue_dst = dst[2];
|
||||
register int 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_red (unsigned char *src, int bpp, int numpix,
|
||||
unsigned char **dst)
|
||||
|
||||
{register unsigned char *rgb_src = src;
|
||||
register unsigned char *red_dst = dst[0];
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(red_dst++) = *rgb_src;
|
||||
rgb_src += offset;
|
||||
}
|
||||
static void
|
||||
extract_red (unsigned char *src,
|
||||
int bpp,
|
||||
int numpix,
|
||||
unsigned char **dst)
|
||||
{
|
||||
register unsigned char *rgb_src = src;
|
||||
register unsigned char *red_dst = dst[0];
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(red_dst++) = *rgb_src;
|
||||
rgb_src += offset;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void extract_green (unsigned char *src, int bpp, int numpix,
|
||||
unsigned char **dst)
|
||||
|
||||
{register unsigned char *rgb_src = src+1;
|
||||
register unsigned char *green_dst = dst[0];
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(green_dst++) = *rgb_src;
|
||||
rgb_src += offset;
|
||||
}
|
||||
static void
|
||||
extract_green (unsigned char *src,
|
||||
int bpp,
|
||||
int numpix,
|
||||
unsigned char **dst)
|
||||
{
|
||||
register unsigned char *rgb_src = src+1;
|
||||
register unsigned char *green_dst = dst[0];
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(green_dst++) = *rgb_src;
|
||||
rgb_src += offset;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void extract_blue (unsigned char *src, int bpp, int numpix,
|
||||
unsigned char **dst)
|
||||
|
||||
{register unsigned char *rgb_src = src+2;
|
||||
register unsigned char *blue_dst = dst[0];
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(blue_dst++) = *rgb_src;
|
||||
rgb_src += offset;
|
||||
}
|
||||
static void
|
||||
extract_blue (unsigned char *src,
|
||||
int bpp,
|
||||
int numpix,
|
||||
unsigned char **dst)
|
||||
{
|
||||
register unsigned char *rgb_src = src+2;
|
||||
register unsigned char *blue_dst = dst[0];
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(blue_dst++) = *rgb_src;
|
||||
rgb_src += offset;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void extract_alpha (unsigned char *src, int bpp, int numpix,
|
||||
unsigned char **dst)
|
||||
|
||||
{register unsigned char *rgb_src = src+3;
|
||||
register unsigned char *alpha_dst = dst[0];
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(alpha_dst++) = *rgb_src;
|
||||
rgb_src += offset;
|
||||
}
|
||||
static void
|
||||
extract_alpha (unsigned char *src,
|
||||
int bpp,
|
||||
int numpix,
|
||||
unsigned char **dst)
|
||||
{
|
||||
register unsigned char *rgb_src = src+3;
|
||||
register unsigned char *alpha_dst = dst[0];
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(alpha_dst++) = *rgb_src;
|
||||
rgb_src += offset;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void extract_cmy (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 *magenta_dst = dst[1];
|
||||
register unsigned char *yellow_dst = dst[2];
|
||||
register int 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_cmy (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 *magenta_dst = dst[1];
|
||||
register unsigned char *yellow_dst = dst[2];
|
||||
register int 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 (unsigned char *src, int bpp, int numpix,
|
||||
unsigned char **dst)
|
||||
|
||||
{register unsigned char *rgb_src = src;
|
||||
register unsigned char *hue_dst = dst[0];
|
||||
register unsigned char *sat_dst = dst[1];
|
||||
register unsigned char *val_dst = dst[2];
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
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_hsv (unsigned char *src,
|
||||
int bpp,
|
||||
int numpix,
|
||||
unsigned char **dst)
|
||||
{
|
||||
register unsigned char *rgb_src = src;
|
||||
register unsigned char *hue_dst = dst[0];
|
||||
register unsigned char *sat_dst = dst[1];
|
||||
register unsigned char *val_dst = dst[2];
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
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,
|
||||
unsigned char **dst)
|
||||
|
||||
{register unsigned char *rgb_src = src;
|
||||
register unsigned char *hue_dst = dst[0];
|
||||
unsigned char dmy;
|
||||
unsigned char *dummy = &dmy;
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
rgb_to_hsv (rgb_src, rgb_src+1, rgb_src+2, hue_dst++, dummy, dummy);
|
||||
rgb_src += offset;
|
||||
}
|
||||
static void
|
||||
extract_hue (unsigned char *src,
|
||||
int bpp,
|
||||
int numpix,
|
||||
unsigned char **dst)
|
||||
{
|
||||
register unsigned char *rgb_src = src;
|
||||
register unsigned char *hue_dst = dst[0];
|
||||
unsigned char dmy;
|
||||
unsigned char *dummy = &dmy;
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
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,
|
||||
unsigned char **dst)
|
||||
|
||||
{register unsigned char *rgb_src = src;
|
||||
register unsigned char *sat_dst = dst[0];
|
||||
unsigned char dmy;
|
||||
unsigned char *dummy = &dmy;
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
rgb_to_hsv (rgb_src, rgb_src+1, rgb_src+2, dummy, sat_dst++, dummy);
|
||||
rgb_src += offset;
|
||||
}
|
||||
static void
|
||||
extract_sat (unsigned char *src,
|
||||
int bpp,
|
||||
int numpix,
|
||||
unsigned char **dst)
|
||||
{
|
||||
register unsigned char *rgb_src = src;
|
||||
register unsigned char *sat_dst = dst[0];
|
||||
unsigned char dmy;
|
||||
unsigned char *dummy = &dmy;
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
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,
|
||||
unsigned char **dst)
|
||||
|
||||
{register unsigned char *rgb_src = src;
|
||||
register unsigned char *val_dst = dst[0];
|
||||
unsigned char dmy;
|
||||
unsigned char *dummy = &dmy;
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
rgb_to_hsv (rgb_src, rgb_src+1, rgb_src+2, dummy, dummy, val_dst++);
|
||||
rgb_src += offset;
|
||||
}
|
||||
static void
|
||||
extract_val (unsigned char *src,
|
||||
int bpp,
|
||||
int numpix,
|
||||
unsigned char **dst)
|
||||
{
|
||||
register unsigned char *rgb_src = src;
|
||||
register unsigned char *val_dst = dst[0];
|
||||
unsigned char dmy;
|
||||
unsigned char *dummy = &dmy;
|
||||
register int count = numpix, offset = bpp;
|
||||
|
||||
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,
|
||||
unsigned char **dst)
|
||||
|
||||
{register unsigned char *rgb_src = src;
|
||||
register unsigned char *cyan_dst = dst[0];
|
||||
register int count = numpix, offset = bpp-1;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(cyan_dst++) = 255 - *(rgb_src++);
|
||||
rgb_src += offset;
|
||||
}
|
||||
static void
|
||||
extract_cyan (unsigned char *src,
|
||||
int bpp,
|
||||
int numpix,
|
||||
unsigned char **dst)
|
||||
{
|
||||
register unsigned char *rgb_src = src;
|
||||
register unsigned char *cyan_dst = dst[0];
|
||||
register int count = numpix, offset = bpp-1;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(cyan_dst++) = 255 - *(rgb_src++);
|
||||
rgb_src += offset;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void extract_magenta (unsigned char *src, int bpp, int numpix,
|
||||
unsigned char **dst)
|
||||
|
||||
{register unsigned char *rgb_src = src+1;
|
||||
register unsigned char *magenta_dst = dst[0];
|
||||
register int count = numpix, offset = bpp-1;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(magenta_dst++) = 255 - *(rgb_src++);
|
||||
rgb_src += offset;
|
||||
}
|
||||
static void
|
||||
extract_magenta (unsigned char *src,
|
||||
int bpp,
|
||||
int numpix,
|
||||
unsigned char **dst)
|
||||
{
|
||||
register unsigned char *rgb_src = src+1;
|
||||
register unsigned char *magenta_dst = dst[0];
|
||||
register int count = numpix, offset = bpp-1;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(magenta_dst++) = 255 - *(rgb_src++);
|
||||
rgb_src += offset;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void extract_yellow (unsigned char *src, int bpp, int numpix,
|
||||
unsigned char **dst)
|
||||
|
||||
{register unsigned char *rgb_src = src+2;
|
||||
register unsigned char *yellow_dst = dst[0];
|
||||
register int count = numpix, offset = bpp-1;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(yellow_dst++) = 255 - *(rgb_src++);
|
||||
rgb_src += offset;
|
||||
}
|
||||
static void
|
||||
extract_yellow (unsigned char *src,
|
||||
int bpp,
|
||||
int numpix,
|
||||
unsigned char **dst)
|
||||
{
|
||||
register unsigned char *rgb_src = src+2;
|
||||
register unsigned char *yellow_dst = dst[0];
|
||||
register int count = numpix, offset = bpp-1;
|
||||
|
||||
while (count-- > 0)
|
||||
{
|
||||
*(yellow_dst++) = 255 - *(rgb_src++);
|
||||
rgb_src += offset;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void extract_cmyk (unsigned char *src, int bpp, int numpix,
|
||||
unsigned char **dst)
|
||||
static void
|
||||
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 *magenta_dst = dst[1];
|
||||
register unsigned char *yellow_dst = dst[2];
|
||||
register unsigned char *black_dst = dst[3];
|
||||
register unsigned char k, s;
|
||||
register int 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;
|
||||
}
|
||||
{
|
||||
register unsigned char *rgb_src = src;
|
||||
register unsigned char *cyan_dst = dst[0];
|
||||
register unsigned char *magenta_dst = dst[1];
|
||||
register unsigned char *yellow_dst = dst[2];
|
||||
register unsigned char *black_dst = dst[3];
|
||||
register unsigned char k, s;
|
||||
register int 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 (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 s, k;
|
||||
register int 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_cyank (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 s, k;
|
||||
register int 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 (unsigned char *src, int bpp, int numpix,
|
||||
unsigned char **dst)
|
||||
|
||||
{register unsigned char *rgb_src = src;
|
||||
register unsigned char *magenta_dst = dst[0];
|
||||
register unsigned char s, k;
|
||||
register int 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_magentak (unsigned char *src,
|
||||
int bpp,
|
||||
int numpix,
|
||||
unsigned char **dst)
|
||||
{
|
||||
register unsigned char *rgb_src = src;
|
||||
register unsigned char *magenta_dst = dst[0];
|
||||
register unsigned char s, k;
|
||||
register int 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 (unsigned char *src, int bpp, int numpix,
|
||||
unsigned char **dst)
|
||||
static void
|
||||
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 s, k;
|
||||
register int 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;
|
||||
}
|
||||
{
|
||||
register unsigned char *rgb_src = src;
|
||||
register unsigned char *yellow_dst = dst[0];
|
||||
register unsigned char s, k;
|
||||
register int 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;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue