static void
compute_image (GimpDrawable *drawable)
{
GimpDrawable *effect;
guchar *scalarfield = NULL;
/* Get some useful info on the input drawable */
/* ========================================== */
if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&border_x, &border_y, &border_w, &border_h))
return;
gimp_progress_init (_("Van Gogh (LIC)"));
if (licvals.effect_convolve == 0)
generatevectors ();
if (licvals.filtlen < 0.1)
licvals.filtlen = 0.1;
l = licvals.filtlen;
dx = dy = licvals.noisemag;
minv = licvals.minv / 10.0;
maxv = licvals.maxv / 10.0;
isteps = licvals.intsteps;
source_drw_has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
effect = gimp_drawable_get (licvals.effect_image_id);
effect_width = effect->width;
effect_height = effect->height;
switch (licvals.effect_channel)
{
case 0:
scalarfield = rgb_to_hsl (effect, LIC_HUE);
break;
case 1:
scalarfield = rgb_to_hsl (effect, LIC_SATURATION);
break;
case 2:
scalarfield = rgb_to_hsl (effect, LIC_BRIGHTNESS);
break;
}
compute_lic (drawable, scalarfield, licvals.effect_operator);
g_free (scalarfield);
/* Update image */
/* ============ */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, border_x, border_y,
border_w, border_h);
gimp_displays_flush ();
}
gint
image_setup (GimpDrawable *drawable,
gint interactive)
{
/* Set the tile cache size */
/* ======================= */
gimp_tile_cache_ntiles ((drawable->width + gimp_tile_width() - 1) /
gimp_tile_width ());
/* Get some useful info on the input drawable */
/* ========================================== */
input_drawable = drawable;
output_drawable = drawable;
if (! gimp_drawable_mask_intersect (drawable->drawable_id, &border_x, &border_y,
&border_w, &border_h))
return FALSE;
width = input_drawable->width;
height = input_drawable->height;
gimp_pixel_rgn_init (&source_region, input_drawable,
0, 0, width, height, FALSE, FALSE);
maxcounter = (glong) width * (glong) height;
if (mapvals.transparent_background == TRUE)
{
gimp_rgba_set (&background, 0.0, 0.0, 0.0, 0.0);
}
else
{
gimp_context_get_background (&background);
gimp_rgb_set_alpha (&background, 1.0);
}
/* Assume at least RGB */
/* =================== */
in_channels = 3;
if (gimp_drawable_has_alpha (input_drawable->drawable_id) == TRUE)
in_channels++;
if (interactive == TRUE)
{
preview_rgb_stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24,
PREVIEW_WIDTH);
preview_rgb_data = g_new0 (guchar, preview_rgb_stride * PREVIEW_HEIGHT);
preview_surface = cairo_image_surface_create_for_data (preview_rgb_data,
CAIRO_FORMAT_RGB24,
PREVIEW_WIDTH,
PREVIEW_HEIGHT,
preview_rgb_stride);
}
return TRUE;
}
static void
color_rotate (GimpDrawable *drawable)
{
GimpPixelRgn srcPR, destPR;
gint width, height;
gint bytes;
guchar *src_row, *dest_row;
gint row;
gint x, y;
if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&x, &y, &width, &height))
{
return;
}
bytes = drawable->bpp;
src_row = g_new (guchar, width * bytes);
dest_row = g_new (guchar, width * bytes);
gimp_pixel_rgn_init (&srcPR, drawable, 0, 0,
drawable->width,
drawable->height, FALSE, FALSE);
gimp_pixel_rgn_init (&destPR, drawable, 0, 0,
drawable->width,
drawable->height, TRUE, TRUE);
for (row = y; row < (y + height); row++)
{
gimp_pixel_rgn_get_row (&srcPR, src_row, x, row, width);
color_rotate_row (src_row, dest_row, row, width, bytes);
gimp_pixel_rgn_set_row (&destPR, dest_row, x, row, width);
if ((row % 10) == 0)
gimp_progress_update ((double) row / (double) height);
}
/* update the processed region */
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x, y, width, height);
g_free (src_row);
g_free (dest_row);
}
static void
mblur (GimpDrawable *drawable,
GimpPreview *preview)
{
gint x, y;
gint width, height;
if (preview)
{
gimp_preview_get_position (preview, &x, &y);
gimp_preview_get_size (preview, &width, &height);
}
else if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&x, &y, &width, &height))
{
return;
}
if (! preview)
gimp_progress_init (_("Motion blurring"));
switch (mbvals.mblur_type)
{
case MBLUR_LINEAR:
mblur_linear (drawable, preview, x, y, width, height);
break;
case MBLUR_RADIAL:
mblur_radial (drawable, preview, x, y, width, height);
break;
case MBLUR_ZOOM:
mblur_zoom (drawable, preview, x, y, width, height);
break;
default:
break;
}
if (! preview)
{
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x, y, width, height);
}
}
/*
* Red Eye Removal Alorithm, based on using a threshold to detect
* red pixels. Having a user-made selection around the eyes will
* prevent incorrect pixels from being selected.
*/
static void
remove_redeye (GimpDrawable *drawable)
{
GimpPixelRgn src_rgn;
GimpPixelRgn dest_rgn;
gint progress, max_progress;
gboolean has_alpha;
gint x, y;
gint width, height;
gint i;
gpointer pr;
if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&x, &y, &width, &height))
return;
gimp_progress_init (_("Removing red eye"));
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
progress = 0;
max_progress = width * height;
gimp_pixel_rgn_init (&src_rgn, drawable,
x, y, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&dest_rgn, drawable,
x, y, width, height, TRUE, TRUE);
for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn), i = 0;
pr != NULL;
pr = gimp_pixel_rgns_process (pr), i++)
{
redeye_inner_loop (src_rgn.data, dest_rgn.data, src_rgn.w, src_rgn.h,
src_rgn.bpp, has_alpha, src_rgn.rowstride);
progress += src_rgn.w * src_rgn.h;
if (i % 16 == 0)
gimp_progress_update ((gdouble) progress / (gdouble) max_progress);
}
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x, y, width, height);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 drawable_id;
gint x, y, width, height;
*nreturn_vals = 1;
*return_vals = values;
gegl_init (NULL, NULL);
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
INIT_I18N();
drawable_id = param[2].data.d_drawable;
if (gimp_drawable_mask_intersect (drawable_id, &x, &y, &width, &height))
{
GeglBuffer *buffer;
GeglBuffer *shadow_buffer;
buffer = gimp_drawable_get_buffer (drawable_id);
shadow_buffer = gimp_drawable_get_shadow_buffer (drawable_id);
gegl_render_op (buffer, shadow_buffer, "gegl:invert", NULL);
g_object_unref (shadow_buffer); /* flushes the shadow tiles */
g_object_unref (buffer);
gimp_drawable_merge_shadow (drawable_id, TRUE);
gimp_drawable_update (drawable_id, x, y, width, height);
gimp_displays_flush ();
}
values[0].data.d_status = status;
gegl_exit ();
}
static void
despeckle (void)
{
GimpPixelRgn src_rgn; /* Source image region */
GimpPixelRgn dst_rgn;
guchar *src;
guchar *dst;
gint img_bpp;
gint x, y;
gint width, height;
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&x, &y, &width, &height))
return;
gimp_pixel_rgn_init (&src_rgn, drawable, x, y, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&dst_rgn, drawable, x, y, width, height, TRUE, TRUE);
src = g_new (guchar, width * height * img_bpp);
dst = g_new (guchar, width * height * img_bpp);
gimp_pixel_rgn_get_rect (&src_rgn, src, x, y, width, height);
despeckle_median (src, dst, width, height, img_bpp, despeckle_radius, FALSE);
gimp_pixel_rgn_set_rect (&dst_rgn, dst, x, y, width, height);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x, y, width, height);
g_free (dst);
g_free (src);
}
/* do the exchanging */
static void
exchange (GimpDrawable *drawable,
GimpPreview *preview)
{
GimpPixelRgn srcPR, destPR;
guchar min_red, min_green, min_blue;
guchar max_red, max_green, max_blue;
guchar from_red, from_green, from_blue;
guchar to_red, to_green, to_blue;
guchar *src_row, *dest_row;
gint x, y, bpp = drawable->bpp;
gboolean has_alpha;
gint x1, y1, y2;
gint width, height;
GimpRGB min;
GimpRGB max;
if (preview)
{
gimp_preview_get_position (preview, &x1, &y1);
gimp_preview_get_size (preview, &width, &height);
}
else if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&x1, &y1, &width, &height))
{
return;
}
y2 = y1 + height;
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
/* allocate memory */
src_row = g_new (guchar, drawable->width * bpp);
gimp_rgb_get_uchar (&xargs.from, &from_red, &from_green, &from_blue);
gimp_rgb_get_uchar (&xargs.to, &to_red, &to_green, &to_blue);
/* get boundary values */
min = xargs.from;
gimp_rgb_subtract (&min, &xargs.threshold);
gimp_rgb_clamp (&min);
gimp_rgb_get_uchar (&min, &min_red, &min_green, &min_blue);
max = xargs.from;
gimp_rgb_add (&max, &xargs.threshold);
gimp_rgb_clamp (&max);
gimp_rgb_get_uchar (&max, &max_red, &max_green, &max_blue);
dest_row = g_new (guchar, drawable->width * bpp);
gimp_pixel_rgn_init (&srcPR, drawable,
x1, y1, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&destPR, drawable,
x1, y1, width, height, (preview == NULL), TRUE);
for (y = y1; y < y2; y++)
{
gimp_pixel_rgn_get_row (&srcPR, src_row, x1, y, width);
for (x = 0; x < width; x++)
{
guchar pixel_red, pixel_green, pixel_blue;
guchar new_red, new_green, new_blue;
guint idx;
/* get current pixel-values */
pixel_red = src_row[x * bpp];
pixel_green = src_row[x * bpp + 1];
pixel_blue = src_row[x * bpp + 2];
idx = x * bpp;
/* want this pixel? */
if (pixel_red >= min_red &&
pixel_red <= max_red &&
pixel_green >= min_green &&
pixel_green <= max_green &&
pixel_blue >= min_blue &&
pixel_blue <= max_blue)
{
guchar red_delta, green_delta, blue_delta;
red_delta = pixel_red > from_red ?
pixel_red - from_red : from_red - pixel_red;
green_delta = pixel_green > from_green ?
pixel_green - from_green : from_green - pixel_green;
blue_delta = pixel_blue > from_blue ?
pixel_blue - from_blue : from_blue - pixel_blue;
new_red = CLAMP (to_red + red_delta, 0, 255);
new_green = CLAMP (to_green + green_delta, 0, 255);
new_blue = CLAMP (to_blue + blue_delta, 0, 255);
}
else
{
new_red = pixel_red;
new_green = pixel_green;
new_blue = pixel_blue;
}
/* fill buffer */
dest_row[idx + 0] = new_red;
dest_row[idx + 1] = new_green;
dest_row[idx + 2] = new_blue;
/* copy alpha-channel */
if (has_alpha)
dest_row[idx + 3] = src_row[x * bpp + 3];
}
/* store the dest */
gimp_pixel_rgn_set_row (&destPR, dest_row, x1, y, width);
/* and tell the user what we're doing */
if (!preview && (y % 10) == 0)
gimp_progress_update ((gdouble) y / (gdouble) height);
}
g_free (src_row);
g_free (dest_row);
if (preview)
{
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview),
&destPR);
}
else
{
gimp_progress_update (1.0);
/* update the processed region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, width, height);
}
}
static void
randomize (GimpDrawable *drawable,
GimpPreview *preview)
{
GimpPixelRgn srcPR, destPR, destPR2, *sp, *dp, *tp;
gint width, height;
gint bytes;
guchar *dest, *d;
guchar *prev_row, *pr;
guchar *cur_row, *cr;
guchar *next_row, *nr;
guchar *tmp;
gint row, col;
gint x, y;
gint cnt;
gint i, j, k;
if (preview)
{
gimp_preview_get_position (preview, &x, &y);
gimp_preview_get_size (preview, &width, &height);
}
else
{
if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&x, &y, &width, &height))
return;
}
bytes = drawable->bpp;
/*
* allocate row buffers
*/
prev_row = g_new (guchar, (width + 2) * bytes);
cur_row = g_new (guchar, (width + 2) * bytes);
next_row = g_new (guchar, (width + 2) * bytes);
dest = g_new (guchar, width * bytes);
/*
* initialize the pixel regions
*/
gimp_pixel_rgn_init (&srcPR, drawable, x, y, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&destPR, drawable, x, y, width, height, TRUE, TRUE);
gimp_pixel_rgn_init (&destPR2, drawable, x, y, width, height, TRUE, TRUE);
sp = &srcPR;
dp = &destPR;
tp = NULL;
pr = prev_row + bytes;
cr = cur_row + bytes;
nr = next_row + bytes;
for (cnt = 1; cnt <= pivals.rndm_rcount; cnt++)
{
/*
* prepare the first row and previous row
*/
randomize_prepare_row (sp, pr, x, y - 1, width);
randomize_prepare_row (sp, cr, x, y, width);
/*
* loop through the rows, applying the selected convolution
*/
for (row = y; row < y + height; row++)
{
/* prepare the next row */
randomize_prepare_row (sp, nr, x, row + 1, width);
d = dest;
for (col = 0; col < width; col++)
{
if (g_rand_int_range (gr, 0, 100) <= (gint) pivals.rndm_pct)
{
switch (rndm_type)
{
/*
* HURL
* Just assign a random value.
*/
case RNDM_HURL:
for (j = 0; j < bytes; j++)
*d++ = g_rand_int_range (gr, 0, 256);
break;
/*
* PICK
* pick at random from a neighboring pixel.
*/
case RNDM_PICK:
k = g_rand_int_range (gr, 0, 9);
for (j = 0; j < bytes; j++)
{
i = col * bytes + j;
switch (k)
{
case 0:
*d++ = (gint) pr[i - bytes];
break;
case 1:
*d++ = (gint) pr[i];
break;
case 2:
*d++ = (gint) pr[i + bytes];
break;
case 3:
*d++ = (gint) cr[i - bytes];
break;
case 4:
*d++ = (gint) cr[i];
break;
case 5:
*d++ = (gint) cr[i + bytes];
break;
case 6:
*d++ = (gint) nr[i - bytes];
break;
case 7:
*d++ = (gint) nr[i];
break;
case 8:
*d++ = (gint) nr[i + bytes];
break;
}
}
break;
/*
* SLUR
* 80% chance it's from directly above,
* 10% from above left,
* 10% from above right.
*/
case RNDM_SLUR:
k = g_rand_int_range (gr, 0, 10);
for (j = 0; j < bytes; j++)
{
i = col*bytes + j;
switch (k )
{
case 0:
*d++ = (gint) pr[i - bytes];
break;
case 9:
*d++ = (gint) pr[i + bytes];
break;
default:
*d++ = (gint) pr[i];
break;
}
}
break;
}
/*
* Otherwise, this pixel was not selected for randomization,
* so use the current value.
*/
}
else
{
for (j = 0; j < bytes; j++)
*d++ = (gint) cr[col*bytes + j];
}
}
/*
* Save the modified row, shuffle the row pointers, and every
* so often, update the progress meter.
*/
gimp_pixel_rgn_set_row (dp, dest, x, row, width);
tmp = pr;
pr = cr;
cr = nr;
nr = tmp;
if (! preview && PROG_UPDATE_TIME)
{
gdouble base = (gdouble) cnt / pivals.rndm_rcount;
gdouble inc = (gdouble) row / (height * pivals.rndm_rcount);
gimp_progress_update (base + inc);
}
}
/*
* if we have more cycles to perform, swap the src and dest Pixel Regions
*/
if (cnt < pivals.rndm_rcount)
{
if (tp != NULL)
{
tp = dp;
dp = sp;
sp = tp;
}
else
{
tp = &srcPR;
sp = &destPR;
dp = &destPR2;
}
}
}
if (! preview)
gimp_progress_update (1.0);
/*
* update the randomized region
*/
if (preview)
{
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview),
dp);
}
else
{
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x, y, width, height);
}
/*
* clean up after ourselves.
*/
g_free (prev_row);
g_free (cur_row);
g_free (next_row);
g_free (dest);
}
/* do the analyzing */
static void
analyze (GimpDrawable *drawable)
{
GimpPixelRgn srcPR;
guchar *src_row, *cmap;
gint x, y, numcol;
gint x1, y1, x2, y2, w, h;
guchar r, g, b;
gint a;
guchar idx;
gboolean gray;
gboolean has_alpha;
gboolean has_sel;
guchar *sel;
GimpPixelRgn selPR;
gint ofsx, ofsy;
GimpDrawable *selDrawable;
gimp_progress_init (_("Colorcube Analysis"));
if (! gimp_drawable_mask_intersect (drawable->drawable_id, &x1, &y1, &w, &h))
return;
x2 = x1 + w;
y2 = y1 + h;
/*
* Get the size of the input image (this will/must be the same
* as the size of the output image).
*/
width = drawable->width;
height = drawable->height;
bpp = drawable->bpp;
has_sel = !gimp_selection_is_empty (imageID);
gimp_drawable_offsets (drawable->drawable_id, &ofsx, &ofsy);
/* initialize the pixel region */
gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, width, height, FALSE, FALSE);
cmap = gimp_image_get_colormap (imageID, &numcol);
gray = (gimp_drawable_is_gray (drawable->drawable_id) ||
gimp_item_is_channel (drawable->drawable_id));
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
selDrawable = gimp_drawable_get (gimp_image_get_selection (imageID));
gimp_pixel_rgn_init (&selPR,
selDrawable,
0, 0, width, height, FALSE, FALSE);
/* allocate row buffer */
src_row = g_new (guchar, (x2 - x1) * bpp);
sel = g_new (guchar, x2 - x1);
for (y = y1; y < y2; y++)
{
gimp_pixel_rgn_get_row (&srcPR, src_row, x1, y, (x2 - x1));
if (has_sel)
gimp_pixel_rgn_get_row (&selPR, sel, x1 + ofsx, y + ofsy, (x2 - x1));
for (x = 0; x < w; x++)
{
/* Start with full opacity. */
a = 255;
/*
* If the image is indexed, fetch RGB values
* from colormap.
*/
if (cmap)
{
idx = src_row[x * bpp];
r = cmap[idx * 3];
g = cmap[idx * 3 + 1];
b = cmap[idx * 3 + 2];
if (has_alpha)
a = src_row[x * bpp + 1];
}
else if (gray)
{
r = g = b = src_row[x * bpp];
if (has_alpha)
a = src_row[x * bpp + 1];
}
else
{
r = src_row[x * bpp];
g = src_row[x * bpp + 1];
b = src_row[x * bpp + 2];
if (has_alpha)
a = src_row[x * bpp + 3];
}
if (has_sel)
a *= sel[x];
else
a *= 255;
if (a != 0)
insertcolor (r, g, b, (gdouble) a * (1.0 / (255.0 * 255.0)));
}
/* tell the user what we're doing */
if ((y % 10) == 0)
gimp_progress_update ((gdouble) y / (gdouble) (y2 - y1));
}
gimp_progress_update (1.0);
/* clean up */
gimp_drawable_detach (selDrawable);
g_free (src_row);
g_free (sel);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpDrawable *drawable;
GimpPDBStatusType status;
GimpRunMode run_mode;
gdouble xhsiz, yhsiz;
GimpRGB background;
status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
*nreturn_vals = 1;
*return_vals = values;
INIT_I18N ();
/* Get the active drawable info */
drawable = gimp_drawable_get (param[2].data.d_drawable);
img_width = gimp_drawable_width (drawable->drawable_id);
img_height = gimp_drawable_height (drawable->drawable_id);
img_has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_width, &sel_height))
return;
/* Calculate scaling parameters */
sel_x2 = sel_x1 + sel_width;
sel_y2 = sel_y1 + sel_height;
cen_x = (double) (sel_x1 + sel_x2 - 1) / 2.0;
cen_y = (double) (sel_y1 + sel_y2 - 1) / 2.0;
xhsiz = (double) (sel_width - 1) / 2.0;
yhsiz = (double) (sel_height - 1) / 2.0;
if (xhsiz < yhsiz)
{
scale_x = yhsiz / xhsiz;
scale_y = 1.0;
}
else if (xhsiz > yhsiz)
{
scale_x = 1.0;
scale_y = xhsiz / yhsiz;
}
else
{
scale_x = 1.0;
scale_y = 1.0;
}
/* Get background color */
gimp_context_get_background (&background);
gimp_rgb_set_alpha (&background, 0.0);
gimp_drawable_get_color_uchar (drawable->drawable_id, &background,
back_color);
/* See how we will run */
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &pcvals);
/* Get information from the dialog */
if (! polarize_dialog (drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are present */
if (nparams != 8)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
pcvals.circle = param[3].data.d_float;
pcvals.angle = param[4].data.d_float;
pcvals.backwards = param[5].data.d_int32;
pcvals.inverse = param[6].data.d_int32;
pcvals.polrec = param[7].data.d_int32;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &pcvals);
break;
default:
break;
}
/* Distort the image */
if ((status == GIMP_PDB_SUCCESS) &&
(gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id)))
{
/* Set the tile cache size */
gimp_tile_cache_ntiles (2 * (drawable->width + gimp_tile_width() - 1) /
gimp_tile_width ());
/* Run! */
polarize (drawable);
/* If run mode is interactive, flush displays */
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &pcvals, sizeof (polarize_vals_t));
}
else if (status == GIMP_PDB_SUCCESS)
status = GIMP_PDB_EXECUTION_ERROR;
values[0].data.d_status = status;
gimp_drawable_detach (drawable);
}
static void
gimp_drawable_stroke_scan_convert (GimpDrawable *drawable,
GimpStrokeOptions *options,
GimpScanConvert *scan_convert)
{
GimpContext *context = GIMP_CONTEXT (options);
GimpImage *image;
gdouble width;
TileManager *base;
TileManager *mask;
gint x, y, w, h;
gint bytes;
gint off_x, off_y;
guchar bg[1] = { 0, };
PixelRegion maskPR, basePR;
image = gimp_item_get_image (GIMP_ITEM (drawable));
/* must call gimp_channel_is_empty() instead of relying on
* gimp_drawable_mask_intersect() because the selection pretends to
* be empty while it is being stroked, to prevent masking itself.
*/
if (gimp_channel_is_empty (gimp_image_get_mask (image)))
{
x = 0;
y = 0;
w = gimp_item_width (GIMP_ITEM (drawable));
h = gimp_item_height (GIMP_ITEM (drawable));
}
else if (! gimp_drawable_mask_intersect (drawable, &x, &y, &w, &h))
{
return;
}
gimp_item_offsets (GIMP_ITEM (drawable), &off_x, &off_y);
width = options->width;
if (options->unit != GIMP_UNIT_PIXEL)
{
gimp_scan_convert_set_pixel_ratio (scan_convert,
image->yresolution /
image->xresolution);
width *= (image->yresolution /
_gimp_unit_get_factor (image->gimp, options->unit));
}
gimp_scan_convert_stroke (scan_convert, width,
options->join_style,
options->cap_style,
options->miter_limit,
options->dash_offset,
options->dash_info);
/* fill a 1-bpp Tilemanager with black, this will describe the shape
* of the stroke.
*/
mask = tile_manager_new (w, h, 1);
pixel_region_init (&maskPR, mask, 0, 0, w, h, TRUE);
color_region (&maskPR, bg);
/* render the stroke into it */
gimp_scan_convert_render (scan_convert, mask,
x + off_x, y + off_y,
options->antialias);
bytes = gimp_drawable_bytes_with_alpha (drawable);
base = tile_manager_new (w, h, bytes);
pixel_region_init (&basePR, base, 0, 0, w, h, TRUE);
pixel_region_init (&maskPR, mask, 0, 0, w, h, FALSE);
switch (options->style)
{
case GIMP_STROKE_STYLE_SOLID:
{
guchar tmp_col[MAX_CHANNELS] = { 0, };
guchar col[MAX_CHANNELS] = { 0, };
gimp_rgb_get_uchar (&context->foreground,
&tmp_col[RED_PIX],
&tmp_col[GREEN_PIX],
&tmp_col[BLUE_PIX]);
gimp_image_transform_color (image, gimp_drawable_type (drawable), col,
GIMP_RGB, tmp_col);
col[bytes - 1] = OPAQUE_OPACITY;
color_region_mask (&basePR, &maskPR, col);
}
break;
case GIMP_STROKE_STYLE_PATTERN:
{
GimpPattern *pattern;
TempBuf *pat_buf;
gboolean new_buf;
pattern = gimp_context_get_pattern (context);
pat_buf = gimp_image_transform_temp_buf (image,
gimp_drawable_type (drawable),
pattern->mask, &new_buf);
pattern_region (&basePR, &maskPR, pat_buf, x, y);
if (new_buf)
temp_buf_free (pat_buf);
}
break;
}
/* Apply to drawable */
pixel_region_init (&basePR, base, 0, 0, w, h, FALSE);
gimp_drawable_apply_region (drawable, &basePR,
TRUE, _("Render Stroke"),
gimp_context_get_opacity (context),
gimp_context_get_paint_mode (context),
NULL, x, y);
tile_manager_unref (mask);
tile_manager_unref (base);
gimp_drawable_update (drawable, x, y, w, h);
}
/*
* Applies the algorithm
*/
static void
retinex (GimpDrawable *drawable,
GimpPreview *preview)
{
gint x, y, width, height;
gint size, bytes;
guchar *src = NULL;
guchar *psrc = NULL;
GimpPixelRgn dst_rgn, src_rgn;
bytes = drawable->bpp;
/*
* Get the size of the current image or its selection.
*/
if (preview)
{
src = gimp_zoom_preview_get_source (GIMP_ZOOM_PREVIEW (preview),
&width, &height, &bytes);
}
else
{
if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&x, &y, &width, &height))
return;
/* Allocate memory */
size = width * height * bytes;
src = g_try_malloc (sizeof (guchar) * size);
if (src == NULL)
{
g_warning ("Failed to allocate memory");
return;
}
memset (src, 0, sizeof (guchar) * size);
/* Fill allocated memory with pixel data */
gimp_pixel_rgn_init (&src_rgn, drawable,
x, y, width, height,
FALSE, FALSE);
gimp_pixel_rgn_get_rect (&src_rgn, src, x, y, width, height);
}
/*
Algorithm for Multi-scale Retinex with color Restoration (MSRCR).
*/
psrc = src;
MSRCR (psrc, width, height, bytes, preview != NULL);
if (preview)
{
gimp_preview_draw_buffer (preview, psrc, width * bytes);
}
else
{
gimp_pixel_rgn_init (&dst_rgn, drawable,
x, y, width, height,
TRUE, TRUE);
gimp_pixel_rgn_set_rect (&dst_rgn, psrc, x, y, width, height);
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x, y, width, height);
}
g_free (src);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpDrawable *drawable;
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint x, y, width, height;
run_mode = param[0].data.d_int32;
INIT_I18N ();
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
drawable = gimp_drawable_get (param[2].data.d_drawable);
if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&x, &y, &width, &height) ||
width < MIN_GAUSSIAN_SCALE ||
height < MIN_GAUSSIAN_SCALE)
{
status = GIMP_PDB_EXECUTION_ERROR;
gimp_drawable_detach (drawable);
values[0].data.d_status = status;
return;
}
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &rvals);
/* First acquire information with a dialog */
if (! retinex_dialog (drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if (nparams != 7)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
rvals.scale = (param[3].data.d_int32);
rvals.nscales = (param[4].data.d_int32);
rvals.scales_mode = (param[5].data.d_int32);
rvals.cvar = (param[6].data.d_float);
}
break;
case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data (PLUG_IN_PROC, &rvals);
break;
default:
break;
}
if ((status == GIMP_PDB_SUCCESS) &&
(gimp_drawable_is_rgb (drawable->drawable_id)))
{
gimp_progress_init (_("Retinex"));
retinex (drawable, NULL);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &rvals, sizeof (RetinexParams));
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
gimp_drawable_detach (drawable);
values[0].data.d_status = status;
}
static void
sharpen (GimpDrawable *drawable)
{
GimpPixelRgn src_rgn; /* Source image region */
GimpPixelRgn dst_rgn; /* Destination image region */
guchar *src_rows[4]; /* Source pixel rows */
guchar *src_ptr; /* Current source pixel */
guchar *dst_row; /* Destination pixel row */
intneg *neg_rows[4]; /* Negative coefficient rows */
intneg *neg_ptr; /* Current negative coefficient */
gint i; /* Looping vars */
gint y; /* Current location in image */
gint row; /* Current row in src_rows */
gint count; /* Current number of filled src_rows */
gint width; /* Byte width of the image */
gint x1; /* Selection bounds */
gint y1;
gint y2;
gint sel_width; /* Selection width */
gint sel_height; /* Selection height */
gint img_bpp; /* Bytes-per-pixel in image */
void (*filter)(int, guchar *, guchar *, intneg *, intneg *, intneg *);
filter = NULL;
if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&x1, &y1, &sel_width, &sel_height))
return;
y2 = y1 + sel_height;
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
/*
* Let the user know what we're doing...
*/
gimp_progress_init (_("Sharpening"));
/*
* Setup for filter...
*/
gimp_pixel_rgn_init (&src_rgn, drawable,
x1, y1, sel_width, sel_height, FALSE, FALSE);
gimp_pixel_rgn_init (&dst_rgn, drawable,
x1, y1, sel_width, sel_height, TRUE, TRUE);
compute_luts ();
width = sel_width * img_bpp;
for (row = 0; row < 4; row ++)
{
src_rows[row] = g_new (guchar, width);
neg_rows[row] = g_new (intneg, width);
}
dst_row = g_new (guchar, width);
/*
* Pre-load the first row for the filter...
*/
gimp_pixel_rgn_get_row (&src_rgn, src_rows[0], x1, y1, sel_width);
for (i = width, src_ptr = src_rows[0], neg_ptr = neg_rows[0];
i > 0;
i --, src_ptr ++, neg_ptr ++)
*neg_ptr = neg_lut[*src_ptr];
row = 1;
count = 1;
/*
* Select the filter...
*/
switch (img_bpp)
{
case 1 :
filter = gray_filter;
break;
case 2 :
filter = graya_filter;
break;
case 3 :
filter = rgb_filter;
break;
case 4 :
filter = rgba_filter;
break;
};
/*
* Sharpen...
*/
for (y = y1; y < y2; y ++)
{
/*
* Load the next pixel row...
*/
if ((y + 1) < y2)
{
/*
* Check to see if our src_rows[] array is overflowing yet...
*/
if (count >= 3)
count --;
/*
* Grab the next row...
*/
gimp_pixel_rgn_get_row (&src_rgn, src_rows[row],
x1, y + 1, sel_width);
for (i = width, src_ptr = src_rows[row], neg_ptr = neg_rows[row];
i > 0;
i --, src_ptr ++, neg_ptr ++)
*neg_ptr = neg_lut[*src_ptr];
count ++;
row = (row + 1) & 3;
}
else
{
/*
* No more pixels at the bottom... Drop the oldest samples...
*/
count --;
}
/*
* Now sharpen pixels and save the results...
*/
if (count == 3)
{
(* filter) (sel_width, src_rows[(row + 2) & 3], dst_row,
neg_rows[(row + 1) & 3] + img_bpp,
neg_rows[(row + 2) & 3] + img_bpp,
neg_rows[(row + 3) & 3] + img_bpp);
/*
* Set the row...
*/
gimp_pixel_rgn_set_row (&dst_rgn, dst_row, x1, y, sel_width);
}
else if (count == 2)
{
if (y == y1) /* first row */
gimp_pixel_rgn_set_row (&dst_rgn, src_rows[0],
x1, y, sel_width);
else /* last row */
gimp_pixel_rgn_set_row (&dst_rgn, src_rows[(sel_height - 1) & 3],
x1, y, sel_width);
}
if ((y & 15) == 0)
gimp_progress_update ((gdouble) (y - y1) / (gdouble) sel_height);
}
/*
* OK, we're done. Free all memory used...
*/
for (row = 0; row < 4; row ++)
{
g_free (src_rows[row]);
g_free (neg_rows[row]);
}
g_free (dst_row);
/*
* Update the screen...
*/
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
x1, y1, sel_width, sel_height);
}
static void
channel_mixer (CmParamsType *mix,
GimpDrawable *drawable)
{
GimpPixelRgn src_rgn, dest_rgn;
gpointer pr;
gboolean has_alpha;
gdouble red_norm, green_norm, blue_norm, black_norm;
gint i, total, processed = 0;
gint x1, y1;
gint width, height;
if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&x1, &y1, &width, &height))
return;
red_norm = cm_calculate_norm (mix, &mix->red);
green_norm = cm_calculate_norm (mix, &mix->green);
blue_norm = cm_calculate_norm (mix, &mix->blue);
black_norm = cm_calculate_norm (mix, &mix->black);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
gimp_pixel_rgn_init (&src_rgn, drawable,
x1, y1, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&dest_rgn, drawable,
x1, y1, width, height, TRUE, TRUE);
total = width * height;
for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn), i = 0;
pr != NULL;
pr = gimp_pixel_rgns_process (pr), i++)
{
const guchar *src = src_rgn.data;
guchar *dest = dest_rgn.data;
gint x, y;
for (y = 0; y < src_rgn.h; y++)
{
const guchar *s = src;
guchar *d = dest;
if (has_alpha)
{
for (x = 0; x < src_rgn.w; x++, s += 4, d += 4)
{
cm_process_pixel (mix, s, d,
red_norm, green_norm, blue_norm,
black_norm);
d[3] = s[3];
}
}
else
{
for (x = 0; x < src_rgn.w; x++, s += 3, d += 3)
{
cm_process_pixel (mix, s, d,
red_norm, green_norm, blue_norm,
black_norm);
}
}
src += src_rgn.rowstride;
dest += dest_rgn.rowstride;
}
processed += src_rgn.w * src_rgn.h;
if (i % 16 == 0)
gimp_progress_update ((gdouble) processed / (gdouble) total);
}
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, width, height);
}
/*
* Photocopy algorithm
* -----------------
* Mask radius = radius of pixel neighborhood for intensity comparison
* Threshold = relative intensity difference which will result in darkening
* Ramp = amount of relative intensity difference before total black
* Blur radius = mask radius / 3.0
*
* Algorithm:
* For each pixel, calculate pixel intensity value to be: avg (blur radius)
* relative diff = pixel intensity / avg (mask radius)
* If relative diff < Threshold
* intensity mult = (Ramp - MIN (Ramp, (Threshold - relative diff))) / Ramp
* pixel intensity *= intensity mult
* Else
* pixel intensity = white
*/
static void
photocopy (GimpDrawable *drawable,
GimpPreview *preview)
{
GimpPixelRgn src_rgn, dest_rgn;
GimpPixelRgn *pr;
gint x, y, width, height;
gint bytes;
gboolean has_alpha;
guchar *dest1;
guchar *dest2;
guchar *src1, *sp_p1, *sp_m1;
guchar *src2, *sp_p2, *sp_m2;
gdouble n_p1[5], n_m1[5];
gdouble n_p2[5], n_m2[5];
gdouble d_p1[5], d_m1[5];
gdouble d_p2[5], d_m2[5];
gdouble bd_p1[5], bd_m1[5];
gdouble bd_p2[5], bd_m2[5];
gdouble *val_p1, *val_m1, *vp1, *vm1;
gdouble *val_p2, *val_m2, *vp2, *vm2;
gint i, j;
gint row, col;
gint terms;
gint progress, max_progress;
gint initial_p1[4];
gint initial_p2[4];
gint initial_m1[4];
gint initial_m2[4];
gdouble radius;
gdouble val;
gdouble std_dev1;
gdouble std_dev2;
gdouble ramp_down;
gdouble ramp_up;
if (preview)
{
gimp_preview_get_position (preview, &x, &y);
gimp_preview_get_size (preview, &width, &height);
}
else
{
if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&x, &y, &width, &height))
return;
}
bytes = drawable->bpp;
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
val_p1 = g_new (gdouble, MAX (width, height));
val_p2 = g_new (gdouble, MAX (width, height));
val_m1 = g_new (gdouble, MAX (width, height));
val_m2 = g_new (gdouble, MAX (width, height));
dest1 = g_new0 (guchar, width * height);
dest2 = g_new0 (guchar, width * height);
progress = 0;
max_progress = width * height * 3;
gimp_pixel_rgn_init (&src_rgn, drawable,
x, y, width, height, FALSE, FALSE);
for (pr = gimp_pixel_rgns_register (1, &src_rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
guchar *src_ptr = src_rgn.data;
guchar *dest_ptr = dest1 + (src_rgn.y - y) * width + (src_rgn.x - x);
for (row = 0; row < src_rgn.h; row++)
{
for (col = 0; col < src_rgn.w; col++)
{
/* desaturate */
if (bytes > 2)
dest_ptr[col] = (guchar) gimp_rgb_to_l_int (src_ptr[col * bytes + 0],
src_ptr[col * bytes + 1],
src_ptr[col * bytes + 2]);
else
dest_ptr[col] = (guchar) src_ptr[col * bytes];
/* compute transfer */
val = pow (dest_ptr[col], (1.0 / GAMMA));
dest_ptr[col] = (guchar) CLAMP (val, 0, 255);
}
src_ptr += src_rgn.rowstride;
dest_ptr += width;
}
if (!preview)
{
progress += src_rgn.w * src_rgn.h;
gimp_progress_update ((gdouble) progress / (gdouble) max_progress);
}
}
/* Calculate the standard deviations */
radius = MAX (1.0, 10 * (1.0 - pvals.sharpness));
radius = fabs (radius) + 1.0;
std_dev1 = sqrt (-(radius * radius) / (2 * log (1.0 / 255.0)));
radius = fabs (pvals.mask_radius) + 1.0;
std_dev2 = sqrt (-(radius * radius) / (2 * log (1.0 / 255.0)));
/* derive the constants for calculating the gaussian from the std dev */
find_constants (n_p1, n_m1, d_p1, d_m1, bd_p1, bd_m1, std_dev1);
find_constants (n_p2, n_m2, d_p2, d_m2, bd_p2, bd_m2, std_dev2);
/* First the vertical pass */
for (col = 0; col < width; col++)
{
memset (val_p1, 0, height * sizeof (gdouble));
memset (val_p2, 0, height * sizeof (gdouble));
memset (val_m1, 0, height * sizeof (gdouble));
memset (val_m2, 0, height * sizeof (gdouble));
src1 = dest1 + col;
sp_p1 = src1;
sp_m1 = src1 + (height - 1) * width;
vp1 = val_p1;
vp2 = val_p2;
vm1 = val_m1 + (height - 1);
vm2 = val_m2 + (height - 1);
/* Set up the first vals */
initial_p1[0] = sp_p1[0];
initial_m1[0] = sp_m1[0];
for (row = 0; row < height; row++)
{
gdouble *vpptr1, *vmptr1;
gdouble *vpptr2, *vmptr2;
terms = (row < 4) ? row : 4;
vpptr1 = vp1; vmptr1 = vm1;
vpptr2 = vp2; vmptr2 = vm2;
for (i = 0; i <= terms; i++)
{
*vpptr1 += n_p1[i] * sp_p1[-i * width] - d_p1[i] * vp1[-i];
*vmptr1 += n_m1[i] * sp_m1[i * width] - d_m1[i] * vm1[i];
*vpptr2 += n_p2[i] * sp_p1[-i * width] - d_p2[i] * vp2[-i];
*vmptr2 += n_m2[i] * sp_m1[i * width] - d_m2[i] * vm2[i];
}
for (j = i; j <= 4; j++)
{
*vpptr1 += (n_p1[j] - bd_p1[j]) * initial_p1[0];
*vmptr1 += (n_m1[j] - bd_m1[j]) * initial_m1[0];
*vpptr2 += (n_p2[j] - bd_p2[j]) * initial_p1[0];
*vmptr2 += (n_m2[j] - bd_m2[j]) * initial_m1[0];
}
sp_p1 += width;
sp_m1 -= width;
vp1 += 1;
vp2 += 1;
vm1 -= 1;
vm2 -= 1;
}
transfer_pixels (val_p1, val_m1, dest1 + col, width, height);
transfer_pixels (val_p2, val_m2, dest2 + col, width, height);
if (!preview)
{
progress += height;
if ((col % 5) == 0)
gimp_progress_update ((gdouble) progress / (gdouble) max_progress);
}
}
for (row = 0; row < height; row++)
{
memset (val_p1, 0, width * sizeof (gdouble));
memset (val_p2, 0, width * sizeof (gdouble));
memset (val_m1, 0, width * sizeof (gdouble));
memset (val_m2, 0, width * sizeof (gdouble));
src1 = dest1 + row * width;
src2 = dest2 + row * width;
sp_p1 = src1;
sp_p2 = src2;
sp_m1 = src1 + width - 1;
sp_m2 = src2 + width - 1;
vp1 = val_p1;
vp2 = val_p2;
vm1 = val_m1 + width - 1;
vm2 = val_m2 + width - 1;
/* Set up the first vals */
initial_p1[0] = sp_p1[0];
initial_p2[0] = sp_p2[0];
initial_m1[0] = sp_m1[0];
initial_m2[0] = sp_m2[0];
for (col = 0; col < width; col++)
{
gdouble *vpptr1, *vmptr1;
gdouble *vpptr2, *vmptr2;
terms = (col < 4) ? col : 4;
vpptr1 = vp1; vmptr1 = vm1;
vpptr2 = vp2; vmptr2 = vm2;
for (i = 0; i <= terms; i++)
{
*vpptr1 += n_p1[i] * sp_p1[-i] - d_p1[i] * vp1[-i];
*vmptr1 += n_m1[i] * sp_m1[i] - d_m1[i] * vm1[i];
*vpptr2 += n_p2[i] * sp_p2[-i] - d_p2[i] * vp2[-i];
*vmptr2 += n_m2[i] * sp_m2[i] - d_m2[i] * vm2[i];
}
for (j = i; j <= 4; j++)
{
*vpptr1 += (n_p1[j] - bd_p1[j]) * initial_p1[0];
*vmptr1 += (n_m1[j] - bd_m1[j]) * initial_m1[0];
*vpptr2 += (n_p2[j] - bd_p2[j]) * initial_p2[0];
*vmptr2 += (n_m2[j] - bd_m2[j]) * initial_m2[0];
}
sp_p1 ++;
sp_p2 ++;
sp_m1 --;
sp_m2 --;
vp1 ++;
vp2 ++;
vm1 --;
vm2 --;
}
transfer_pixels (val_p1, val_m1, dest1 + row * width, 1, width);
transfer_pixels (val_p2, val_m2, dest2 + row * width, 1, width);
if (!preview)
{
progress += width;
if ((row % 5) == 0)
gimp_progress_update ((gdouble) progress / (gdouble) max_progress);
}
}
/* Compute the ramp value which sets 'pct_black' % of the darkened pixels black */
ramp_down = compute_ramp (dest1, dest2, width * height, pvals.pct_black, 1);
ramp_up = compute_ramp (dest1, dest2, width * height, 1.0 - pvals.pct_white, 0);
/* Initialize the pixel regions. */
gimp_pixel_rgn_init (&src_rgn, drawable, x, y, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&dest_rgn, drawable, x, y, width, height,
(preview == NULL), TRUE);
pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
while (pr)
{
guchar *src_ptr = src_rgn.data;
guchar *dest_ptr = dest_rgn.data;
guchar *blur_ptr = dest1 + (src_rgn.y - y) * width + (src_rgn.x - x);
guchar *avg_ptr = dest2 + (src_rgn.y - y) * width + (src_rgn.x - x);
gdouble diff, mult;
gdouble lightness = 0.0;
for (row = 0; row < src_rgn.h; row++)
{
for (col = 0; col < src_rgn.w; col++)
{
if (avg_ptr[col] > EPSILON)
{
diff = (gdouble) blur_ptr[col] / (gdouble) avg_ptr[col];
if (diff < pvals.threshold)
{
if (ramp_down == 0.0)
mult = 0.0;
else
mult = (ramp_down - MIN (ramp_down,
(pvals.threshold - diff))) / ramp_down;
lightness = CLAMP (blur_ptr[col] * mult, 0, 255);
}
else
{
if (ramp_up == 0.0)
mult = 1.0;
else
mult = MIN (ramp_up,
(diff - pvals.threshold)) / ramp_up;
lightness = 255 - (1.0 - mult) * (255 - blur_ptr[col]);
lightness = CLAMP (lightness, 0, 255);
}
}
else
{
lightness = 0;
}
if (bytes < 3)
{
dest_ptr[col * bytes] = (guchar) lightness;
if (has_alpha)
dest_ptr[col * bytes + 1] = src_ptr[col * src_rgn.bpp + 1];
}
else
{
dest_ptr[col * bytes + 0] = lightness;
dest_ptr[col * bytes + 1] = lightness;
dest_ptr[col * bytes + 2] = lightness;
if (has_alpha)
dest_ptr[col * bytes + 3] = src_ptr[col * src_rgn.bpp + 3];
}
}
src_ptr += src_rgn.rowstride;
dest_ptr += dest_rgn.rowstride;
blur_ptr += width;
avg_ptr += width;
}
if (preview)
{
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview),
&dest_rgn);
}
else
{
progress += src_rgn.w * src_rgn.h;
gimp_progress_update ((gdouble) progress / (gdouble) max_progress);
}
pr = gimp_pixel_rgns_process (pr);
}
if (! preview)
{
gimp_progress_update (1.0);
/* merge the shadow, update the drawable */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x, y, width, height);
}
/* free up buffers */
g_free (val_p1);
g_free (val_p2);
g_free (val_m1);
g_free (val_m2);
g_free (dest1);
g_free (dest2);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[2];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 drawable_id;
run_mode = param[0].data.d_int32;
INIT_I18N ();
set_default_params ();
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &curl);
*nreturn_vals = 2;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
values[1].type = GIMP_PDB_LAYER;
values[1].data.d_layer = -1;
/* Get the specified drawable */
drawable_id = param[2].data.d_drawable;
image_id = param[1].data.d_image;
if ((gimp_drawable_is_rgb (drawable_id) ||
gimp_drawable_is_gray (drawable_id)) &&
gimp_drawable_mask_intersect (drawable_id, &sel_x, &sel_y,
&true_sel_width, &true_sel_height))
{
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* First acquire information with a dialog */
if (! dialog ())
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if (nparams != 7)
status = GIMP_PDB_CALLING_ERROR;
if (status == GIMP_PDB_SUCCESS)
{
curl.colors = CLAMP (param[3].data.d_int32,
0, CURL_COLORS_LAST);
curl.edge = CLAMP (param[4].data.d_int32,
CURL_EDGE_FIRST, CURL_EDGE_LAST);
curl.orientation = CLAMP (param[5].data.d_int32,
0, CURL_ORIENTATION_LAST);
curl.shade = param[6].data.d_int32 ? TRUE : FALSE;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS)
{
values[1].data.d_layer = page_curl (drawable_id);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &curl, sizeof (CurlParams));
}
}
else
/* Sorry - no indexed/noalpha images */
status = GIMP_PDB_EXECUTION_ERROR;
values[0].data.d_status = status;
}
static void
value_propagate_body (GimpDrawable *drawable,
GimpPreview *preview)
{
GimpImageType dtype;
ModeParam operation;
GimpPixelRgn srcRgn, destRgn;
guchar *here, *best, *dest;
guchar *dest_row, *prev_row, *cur_row, *next_row;
guchar *pr, *cr, *nr, *swap;
gint width, height, bytes, index;
gint begx, begy, endx, endy, x, y, dx;
gint left_index, right_index, up_index, down_index;
gpointer tmp;
GimpRGB foreground;
/* calculate neighbors' indexes */
left_index = (vpvals.direction_mask & (1 << Left2Right)) ? -1 : 0;
right_index = (vpvals.direction_mask & (1 << Right2Left)) ? 1 : 0;
up_index = (vpvals.direction_mask & (1 << Top2Bottom)) ? -1 : 0;
down_index = (vpvals.direction_mask & (1 << Bottom2Top)) ? 1 : 0;
operation = modes[vpvals.propagate_mode];
tmp = NULL;
dtype = gimp_drawable_type (drawable->drawable_id);
bytes = drawable->bpp;
/* Here I use the algorithm of blur.c */
if (preview)
{
gimp_preview_get_position (preview, &begx, &begy);
gimp_preview_get_size (preview, &width, &height);
endx = begx + width;
endy = begy + height;
}
else
{
if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&begx, &begy, &width, &height))
return;
endx = begx + width;
endy = begy + height;
}
gimp_tile_cache_ntiles (2 * ((width) / gimp_tile_width () + 1));
prev_row = g_new (guchar, (width + 2) * bytes);
cur_row = g_new (guchar, (width + 2) * bytes);
next_row = g_new (guchar, (width + 2) * bytes);
dest_row = g_new (guchar, width * bytes);
gimp_pixel_rgn_init (&srcRgn, drawable,
begx, begy, width, height,
FALSE, FALSE);
gimp_pixel_rgn_init (&destRgn, drawable,
begx, begy, width, height,
(preview == NULL), TRUE);
pr = prev_row + bytes;
cr = cur_row + bytes;
nr = next_row + bytes;
prepare_row (&srcRgn, pr, begx, (0 < begy) ? begy : begy - 1, endx-begx);
prepare_row (&srcRgn, cr, begx, begy, endx-begx);
best = g_new (guchar, bytes);
if (!preview)
gimp_progress_init (_("Value Propagate"));
gimp_context_get_foreground (&foreground);
gimp_rgb_get_uchar (&foreground, fore+0, fore+1, fore+2);
/* start real job */
for (y = begy ; y < endy ; y++)
{
prepare_row (&srcRgn, nr, begx, ((y+1) < endy) ? y+1 : endy, endx-begx);
for (index = 0; index < (endx - begx) * bytes; index++)
dest_row[index] = cr[index];
for (x = 0 ; x < endx - begx; x++)
{
dest = dest_row + (x * bytes);
here = cr + (x * bytes);
/* *** copy source value to best value holder *** */
memcpy (best, here, bytes);
if (operation.initializer)
(* operation.initializer)(dtype, bytes, best, here, &tmp);
/* *** gather neighbors' values: loop-unfolded version *** */
if (up_index == -1)
for (dx = left_index ; dx <= right_index ; dx++)
(* operation.updater)(dtype, bytes, here, pr+((x+dx)*bytes), best, tmp);
for (dx = left_index ; dx <= right_index ; dx++)
if (dx != 0)
(* operation.updater)(dtype, bytes, here, cr+((x+dx)*bytes), best, tmp);
if (down_index == 1)
for (dx = left_index ; dx <= right_index ; dx++)
(* operation.updater)(dtype, bytes, here, nr+((x+dx)*bytes), best, tmp);
/* *** store it to dest_row*** */
(* operation.finalizer)(dtype, bytes, best, here, dest, tmp);
}
/* now store destline to destRgn */
gimp_pixel_rgn_set_row (&destRgn, dest_row, begx, y, endx - begx);
/* shift the row pointers */
swap = pr;
pr = cr;
cr = nr;
nr = swap;
if (((y % 16) == 0) && !preview)
gimp_progress_update ((gdouble) y / (gdouble) (endy - begy));
}
if (preview)
{
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview),
&destRgn);
}
else
{
/* update the region */
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, begx, begy, endx-begx, endy-begy);
}
}
static void
brushdmenuselect (GtkWidget *widget,
gpointer data)
{
GimpPixelRgn src_rgn;
guchar *src_row;
guchar *src;
gint id;
gint bpp;
gint x, y;
ppm_t *p;
gint x1, y1, w, h;
gint row;
GimpDrawable *drawable;
gint rowstride;
gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &id);
if (id == -1)
return;
if (brush_from_file == 2)
return; /* Not finished GUI-building yet */
if (brush_from_file)
{
#if 0
unselectall (brush_list);
#endif
preset_save_button_set_sensitive (FALSE);
}
gtk_adjustment_set_value (brush_gamma_adjust, 1.0);
gtk_adjustment_set_value (brush_aspect_adjust, 0.0);
drawable = gimp_drawable_get (id);
if (! gimp_drawable_mask_intersect (drawable->drawable_id, &x1, &y1, &w, &h))
return;
bpp = gimp_drawable_bpp (drawable->drawable_id);
ppm_kill (&brushppm);
ppm_new (&brushppm, w, h);
p = &brushppm;
rowstride = p->width * 3;
src_row = g_new (guchar, w * bpp);
gimp_pixel_rgn_init (&src_rgn, drawable,
0, 0, w, h, FALSE, FALSE);
if (bpp == 3)
{ /* RGB */
gint bpr = w * 3;
gint y2 = y1 + h;
for (row = 0, y = y1; y < y2; row++, y++)
{
gimp_pixel_rgn_get_row (&src_rgn, src_row, x1, y, w);
memcpy (p->col + row*rowstride, src_row, bpr);
}
}
else
{ /* RGBA (bpp > 3) GrayA (bpp == 2) or Gray */
gboolean is_gray = ((bpp > 3) ? TRUE : FALSE);
gint y2 = y1 + h;
for (row = 0, y = y1; y < y2; row++, y++)
{
guchar *tmprow = p->col + row * rowstride;
guchar *tmprow_ptr;
gint x2 = x1 + w;
gimp_pixel_rgn_get_row (&src_rgn, src_row, x1, y, w);
src = src_row;
tmprow_ptr = tmprow;
/* Possible micro-optimization here:
* src_end = src + src_rgn.bpp * w);
* for ( ; src < src_end ; src += src_rgn.bpp)
*/
for (x = x1; x < x2; x++)
{
*(tmprow_ptr++) = src[0];
*(tmprow_ptr++) = src[is_gray ? 1 : 0];
*(tmprow_ptr++) = src[is_gray ? 2 : 0];
src += src_rgn.bpp;
}
}
}
g_free (src_row);
if (bpp >= 3)
pcvals.color_brushes = 1;
else
pcvals.color_brushes = 0;
brush_from_file = 0;
update_brush_preview (NULL);
}
