/*
This function operates on PixelArea, whose width and height are
multiply of pixel width, and less than the tile size (to enhance
its speed).
If any coordinates of mask boundary is not multiply of pixel width
(e.g. x1 % pixelwidth != 0), operates on the region whose width
or height is the remainder.
*/
static void
pixelize_small (GimpDrawable *drawable,
gint pixelwidth,
gint pixelheight,
gint tile_width,
gint tile_height)
{
GimpPixelRgn src_rgn, dest_rgn;
gint bpp, has_alpha;
gint x1, y1, x2, y2;
gint progress, max_progress;
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_pixel_rgn_init (&src_rgn, drawable, x1, y1, x2-x1, y2-y1, FALSE, FALSE);
gimp_pixel_rgn_init (&dest_rgn, drawable, x1, y1, x2-x1, y2-y1, TRUE, TRUE);
/* Initialize progress */
progress = 0;
max_progress = (x2 - x1) * (y2 - y1);
bpp = drawable->bpp;
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
area.width = (tile_width / pixelwidth) * pixelwidth;
area.height = (tile_height / pixelheight) * pixelheight;
area.data= g_new (guchar, (glong) bpp * area.width * area.height);
for (area.y = y1; area.y < y2;
area.y += area.height - (area.y % area.height))
{
area.h = area.height - (area.y % area.height);
area.h = MIN (area.h, y2 - area.y);
for (area.x = x1; area.x < x2;
area.x += area.width - (area.x % area.width))
{
area.w = area.width - (area.x % area.width);
area.w = MIN(area.w, x2 - area.x);
gimp_pixel_rgn_get_rect (&src_rgn, area.data,
area.x, area.y, area.w, area.h);
pixelize_sub (pixelwidth, pixelheight, bpp, has_alpha);
gimp_pixel_rgn_set_rect (&dest_rgn, area.data,
area.x, area.y, area.w, area.h);
/* Update progress */
progress += area.w * area.h;
gimp_progress_update ((double) progress / (double) max_progress);
}
}
g_free(area.data);
/* update the pixelized region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
static void octave (GimpDrawable *drawable)
{
GimpPixelRgn srcPR, destPR;
gint x1, y1, x2, y2;
gint x, y, width, height;
/* initialize pixel regions */
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);
/* Get the input */
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
x=x1;
y=y1;
width=x2-x1;
height=y2-y1;
/* Run */
octave_region (&srcPR, &destPR, drawable->bpp, x, y, width, height);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, x2 - x1, y2 - y1);
}
//-------------------------------------------------------------------------
static void
c2g_mask (GimpDrawable *drawable,
gdouble radius,
gdouble amount,
gdouble gamma)
{
GimpPixelRgn srcPR, destPR;
gint x1, y1, x2, y2;
/* initialize pixel regions */
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);
/* Get the input */
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
c2g_region (&srcPR, &destPR, drawable->bpp,
radius, amount, gamma,
x1, x2, y1, y2,
TRUE);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, x2 - x1, y2 - y1);
}
static void
compute_image (GimpDrawable *drawable)
{
GimpDrawable *effect;
guchar *scalarfield = NULL;
/* Get some useful info on the input drawable */
/* ========================================== */
gimp_drawable_mask_bounds (drawable->drawable_id,
&border_x1, &border_y1, &border_x2, &border_y2);
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_x1, border_y1,
border_x2 - border_x1, border_y2 - border_y1);
gimp_displays_flush ();
}
static void
sinus (void)
{
params p;
gint bytes;
GimpPixelRgn dest_rgn;
gint x1, y1, x2, y2;
gpointer pr;
gint progress, max_progress;
prepare_coef(&p);
gimp_drawable_mask_bounds(drawable->drawable_id, &x1, &y1, &x2, &y2);
p.width = drawable->width;
p.height = drawable->height;
bytes = drawable->bpp;
gimp_pixel_rgn_init (&dest_rgn, drawable,
x1, y1, x2 - x1, y2 - y1, TRUE,TRUE);
progress = 0;
max_progress = (x2 - x1) * (y2 - y1);
for (pr = gimp_pixel_rgns_register (1, &dest_rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
switch (bytes)
{
case 4:
compute_block_x (dest_rgn.data, dest_rgn.rowstride,
dest_rgn.x, dest_rgn.y, dest_rgn.w, dest_rgn.h,
4, assign_block_4, &p);
break;
case 3:
compute_block_x (dest_rgn.data, dest_rgn.rowstride,
dest_rgn.x, dest_rgn.y, dest_rgn.w, dest_rgn.h,
3, assign_block_3, &p);
break;
case 2:
compute_block_x (dest_rgn.data, dest_rgn.rowstride,
dest_rgn.x, dest_rgn.y, dest_rgn.w, dest_rgn.h,
2, assign_block_2, &p);
break;
case 1:
compute_block_x (dest_rgn.data, dest_rgn.rowstride,
dest_rgn.x, dest_rgn.y, dest_rgn.w, dest_rgn.h,
1, assign_block_1, &p);
break;
}
progress += dest_rgn.w * dest_rgn.h;
gimp_progress_update ((double) progress / (double) max_progress);
}
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, x2 - x1, y2 - y1);
}
gint32 execute_plugin(GimpDrawable* d, const char *nome, param_type *p)
{
// gint i;
guchar *img, *org;
gint x,y,x2,y2,w,h;
// guchar *work;
GimpPixelRgn region, rgn_org;
gint bpp = d->bpp;
gimp_drawable_mask_bounds(d->drawable_id, &x, &y, &x2, &y2);
w = x2 - x;
h = y2 - y;
img = malloc(w * h * bpp);
org = malloc(w * h * bpp);
// work = malloc(d.width * d.height * bpp);
gimp_pixel_rgn_init(®ion, d, x, y, w, h, TRUE, TRUE);
//este é buffer para gravar a imagem modificada.
gimp_pixel_rgn_init(&rgn_org, d, x, y, w, h, FALSE, FALSE);
// Esta é a imagem em si
gimp_pixel_rgn_get_rect(®ion, img, x, y, w, h);
gimp_pixel_rgn_get_rect(&rgn_org, org, x, y, w, h);
switch (*nome) {
case 'S':
super_grow(p, org, img, w, h, bpp);
break;
case 'G':
memcpy(img, org, w * h * bpp);
grow(p, org, img, w, h, bpp);
break;
case 'A':
find_iso(p, org, img, w, h, bpp);
break;
default:
make_height_field(p, org, img, w, h, bpp);
break;
}
gimp_pixel_rgn_set_rect(®ion, img, x, y, w, h);
/* finish the process */
gimp_drawable_flush (d);
gimp_drawable_merge_shadow (d->drawable_id, TRUE);
gimp_drawable_update (d->drawable_id, x, y, w, h);
gimp_displays_flush();
gimp_drawable_detach(d);
free(img);
free(org);
return GIMP_PDB_SUCCESS;
}
void
gimp_rgn_iterate1 (GimpDrawable *drawable,
GimpRunMode unused,
GimpRgnFunc1 func,
gpointer data)
{
GimpPixelRgn srcPR;
gint x1, y1, x2, y2;
gpointer pr;
gint total_area;
gint area_so_far;
gint progress_skip;
g_return_if_fail (drawable != NULL);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
total_area = (x2 - x1) * (y2 - y1);
if (total_area <= 0)
return;
area_so_far = 0;
progress_skip = 0;
gimp_pixel_rgn_init (&srcPR, drawable,
x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE);
for (pr = gimp_pixel_rgns_register (1, &srcPR);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
guchar *src = srcPR.data;
gint y;
for (y = 0; y < srcPR.h; y++)
{
guchar *s = src;
gint x;
for (x = 0; x < srcPR.w; x++)
{
func (s, srcPR.bpp, data);
s += srcPR.bpp;
}
src += srcPR.rowstride;
}
area_so_far += srcPR.w * srcPR.h;
if (((progress_skip++) % 10) == 0)
gimp_progress_update ((gdouble) area_so_far / (gdouble) total_area);
}
}
static GimpPDBStatusType
run_pspi (const gchar *pdb_name,
gint n_params,
const GimpParam *param)
{
GimpRunMode run_mode = param[0].data.d_int32;
GimpDrawable *drawable;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
PSPlugInEntry *pspie;
gint x1, y1, x2, y2;
get_saved_plugin_data ();
if ((pspie = g_hash_table_lookup (entry_hash, pdb_name)) != NULL)
{
gchar *name;
if (run_mode == GIMP_RUN_NONINTERACTIVE)
{
if (n_params != standard_nargs)
return GIMP_PDB_CALLING_ERROR;
}
else if (run_mode == GIMP_RUN_INTERACTIVE)
{
if ((status = pspi_params (pspie)) != GIMP_PDB_SUCCESS)
return status;
}
drawable = gimp_drawable_get (param[2].data.d_drawable);
gimp_ui_init (PLUGIN_NAME, TRUE);
if ((status = pspi_prepare (pspie, drawable)) != GIMP_PDB_SUCCESS)
return status;
name = g_strdup_printf (_("Applying %s:"),
strrchr (pspie->menu_path, '/') + 1);
gimp_progress_init (name);
g_free (name);
if ((status = pspi_apply (pspie, drawable)) != GIMP_PDB_SUCCESS)
return status;
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
gimp_displays_flush ();
return GIMP_PDB_SUCCESS;
}
return GIMP_PDB_CALLING_ERROR;
}
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;
gimp_drawable_mask_bounds (drawable->drawable_id,
&border_x1, &border_y1, &border_x2, &border_y2);
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_data = g_new0 (guchar, PREVIEW_HEIGHT * PREVIEW_WIDTH * 3);
}
return TRUE;
}
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
{
gimp_drawable_mask_bounds (drawable->drawable_id,
&x, &y, &width, &height);
width -= x;
height -= y;
}
if (width < 1 || height < 1)
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_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x, y, width, height);
}
}
void
gimp_rgn_iterate2 (GimpDrawable *drawable,
GimpRunMode unused,
GimpRgnFunc2 func,
gpointer data)
{
GimpPixelRgn srcPR, destPR;
gint x1, y1, x2, y2;
gpointer pr;
gint total_area;
gint area_so_far;
gint progress_skip;
g_return_if_fail (drawable != NULL);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
total_area = (x2 - x1) * (y2 - y1);
if (total_area <= 0)
return;
area_so_far = 0;
progress_skip = 0;
/* Initialize the pixel regions. */
gimp_pixel_rgn_init (&srcPR, drawable, x1, y1, (x2 - x1), (y2 - y1),
FALSE, FALSE);
gimp_pixel_rgn_init (&destPR, drawable, x1, y1, (x2 - x1), (y2 - y1),
TRUE, TRUE);
for (pr = gimp_pixel_rgns_register (2, &srcPR, &destPR);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
gimp_rgn_render_region (&srcPR, &destPR, func, data);
area_so_far += srcPR.w * srcPR.h;
if (((progress_skip++) % 10) == 0)
gimp_progress_update ((gdouble) area_so_far / (gdouble) total_area);
}
/* update the processed region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
/**
* gimp_rgn_iterator_new:
* @drawable: a #GimpDrawable
* @unused: ignored
*
* Creates a new #GimpRgnIterator for @drawable. The #GimpRunMode
* parameter is ignored. Use gimp_rgn_iterator_free() to free thsi
* iterator.
*
* Return value: a newly allocated #GimpRgnIterator.
**/
GimpRgnIterator *
gimp_rgn_iterator_new (GimpDrawable *drawable,
GimpRunMode unused)
{
GimpRgnIterator *iter;
g_return_val_if_fail (drawable != NULL, NULL);
iter = g_slice_new (GimpRgnIterator);
iter->drawable = drawable;
gimp_drawable_mask_bounds (drawable->drawable_id,
&iter->x1, &iter->y1,
&iter->x2, &iter->y2);
return iter;
}
static void blur (GimpDrawable *drawable) {
gint i, j, k, channels;
gint x1, y1, x2, y2;
GimpPixelRgn rgn_in, rgn_out;
guchar *row1, *row2, *row3;
guchar *outrow;
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
channels = gimp_drawable_bpp (drawable->drawable_id);
gimp_pixel_rgn_init (&rgn_in, drawable, x1, y1, x2 - x1, y2 - y1, FALSE, FALSE);
gimp_pixel_rgn_init (&rgn_out, drawable, x1, y1, x2 - x1, y2 - y1, TRUE, TRUE);
/* Initialise enough memory for row1, row2, row3, outrow */
row1 = g_new (guchar, channels * (x2 - x1));
outrow = g_new (guchar, channels * (x2 - x1));
for (i = y1; i < y2; i++) {
/* Get row i-1, i, i+1 */
gimp_pixel_rgn_get_row (&rgn_in, row1, x1, MAX (y1, i - 1), x2 - x1);
for (j = x1; j < x2; j++) {
/* For each layer, compute the average of the nine pixels */
for (k = 0; k < channels; k++) {
int in = row1[channels * (j - x1) + k];
int a = (1.0 - (in / 255.0)) * 100.0;
int r = rand() % 100;
outrow[channels * (j - x1) + k] = r < a ? 0 : 255;
}
}
gimp_pixel_rgn_set_row (&rgn_out, outrow, x1, i, x2 - x1);
if (i % 10 == 0)
gimp_progress_update ((gdouble) (i - y1) / (gdouble) (y2 - y1));
}
g_free (row1);
g_free (outrow);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, x2 - x1, y2 - y1);
}
static void
dog (gint32 image_ID,
GimpDrawable *drawable,
gdouble inner,
gdouble outer,
gboolean show_progress)
{
GimpDrawable *drawable1;
GimpDrawable *drawable2;
gint32 drawable_id = drawable->drawable_id;
gint32 layer1;
gint32 layer2;
gint width, height;
gint x1, y1, x2, y2;
guchar maxval = 255;
gimp_drawable_mask_bounds (drawable_id, &x1, &y1, &x2, &y2);
width = (x2 - x1);
height = (y2 - y1);
gimp_drawable_flush (drawable);
layer1 = gimp_layer_copy (drawable_id);
gimp_drawable_set_visible (layer1, FALSE);
gimp_drawable_set_name (layer1, "dog_scratch_layer1");
gimp_image_add_layer (image_ID, layer1, 0);
layer2 = gimp_layer_copy (drawable_id);
gimp_drawable_set_visible (layer2, FALSE);
gimp_drawable_set_name (layer2, "dog_scratch_layer2");
gimp_image_add_layer (image_ID, layer2, 0);
drawable1 = gimp_drawable_get (layer1);
drawable2 = gimp_drawable_get (layer2);
gauss_rle (drawable1, inner, 0, show_progress);
gauss_rle (drawable2, outer, 1, show_progress);
compute_difference (drawable, drawable1, drawable2, &maxval);
gimp_drawable_detach (drawable1);
gimp_drawable_detach (drawable2);
gimp_image_remove_layer (image_ID, layer1);
gimp_image_remove_layer (image_ID, layer2);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable_id, TRUE);
gimp_drawable_update (drawable_id, x1, y1, width, height);
if (dogvals.normalize)
{
normalize (drawable, maxval);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable_id, TRUE);
gimp_drawable_update (drawable_id, x1, y1, width, height);
}
if (dogvals.invert)
gimp_invert (drawable_id);
}
/*
* Cartoon 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
*/
static void
cartoon (GimpDrawable *drawable,
GimpPreview *preview)
{
GimpPixelRgn src_rgn, dest_rgn;
GimpPixelRgn *pr;
gint width, height;
gint bytes;
gboolean has_alpha;
guchar *dest1;
guchar *dest2;
guchar *src;
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 x1, y1, x2, y2;
gint i, j;
gint row, col, b;
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 std_dev1;
gdouble std_dev2;
gdouble ramp;
guchar *preview_buffer = NULL;
if (preview)
{
gimp_preview_get_position (preview, &x1, &y1);
gimp_preview_get_size (preview, &width, &height);
}
else
{
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = (x2 - x1);
height = (y2 - y1);
}
bytes = drawable->bpp;
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
val_p1 = g_new (gdouble, MAX (width, height) * bytes);
val_p2 = g_new (gdouble, MAX (width, height) * bytes);
val_m1 = g_new (gdouble, MAX (width, height) * bytes);
val_m2 = g_new (gdouble, MAX (width, height) * bytes);
src = g_new (guchar, MAX (width, height) * bytes);
dest1 = g_new0 (guchar, width * height);
dest2 = g_new0 (guchar, width * height);
gimp_pixel_rgn_init (&src_rgn, drawable,
0, 0, drawable->width, drawable->height, FALSE, FALSE);
progress = 0;
max_progress = width * height * 2;
/* Calculate the standard deviations */
radius = 1.0; /* blur radius */
radius = fabs (radius) + 1.0;
std_dev1 = sqrt (-(radius * radius) / (2 * log (1.0 / 255.0)));
radius = cvals.mask_radius;
radius = fabs (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 * bytes * sizeof (gdouble));
memset (val_p2, 0, height * bytes * sizeof (gdouble));
memset (val_m1, 0, height * bytes * sizeof (gdouble));
memset (val_m2, 0, height * bytes * sizeof (gdouble));
gimp_pixel_rgn_get_col (&src_rgn, src, col + x1, y1, height);
src1 = src;
sp_p1 = src1;
sp_m1 = src1 + (height - 1) * bytes;
vp1 = val_p1;
vp2 = val_p2;
vm1 = val_m1 + (height - 1) * bytes;
vm2 = val_m2 + (height - 1) * bytes;
/* Set up the first vals */
for (i = 0; i < bytes; i++)
{
initial_p1[i] = sp_p1[i];
initial_m1[i] = sp_m1[i];
}
for (row = 0; row < height; row++)
{
gdouble *vpptr1, *vmptr1;
gdouble *vpptr2, *vmptr2;
terms = (row < 4) ? row : 4;
for (b = 0; b < bytes; b++)
{
vpptr1 = vp1 + b; vmptr1 = vm1 + b;
vpptr2 = vp2 + b; vmptr2 = vm2 + b;
for (i = 0; i <= terms; i++)
{
*vpptr1 += n_p1[i] * sp_p1[(-i * bytes) + b] -
d_p1[i] * vp1[(-i * bytes) + b];
*vmptr1 += n_m1[i] * sp_m1[(i * bytes) + b] -
d_m1[i] * vm1[(i * bytes) + b];
*vpptr2 += n_p2[i] * sp_p1[(-i * bytes) + b] -
d_p2[i] * vp2[(-i * bytes) + b];
*vmptr2 += n_m2[i] * sp_m1[(i * bytes) + b] -
d_m2[i] * vm2[(i * bytes) + b];
}
for (j = i; j <= 4; j++)
{
*vpptr1 += (n_p1[j] - bd_p1[j]) * initial_p1[b];
*vmptr1 += (n_m1[j] - bd_m1[j]) * initial_m1[b];
*vpptr2 += (n_p2[j] - bd_p2[j]) * initial_p1[b];
*vmptr2 += (n_m2[j] - bd_m2[j]) * initial_m1[b];
}
}
sp_p1 += bytes;
sp_m1 -= bytes;
vp1 += bytes;
vp2 += bytes;
vm1 -= bytes;
vm2 -= bytes;
}
transfer_pixels (val_p1, val_m1, dest1 + col, width, bytes, height);
transfer_pixels (val_p2, val_m2, dest2 + col, width, bytes, 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, 1, width);
transfer_pixels (val_p2, val_m2, dest2 + row * width, 1, 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 = compute_ramp (dest1, dest2, width * height, cvals.pct_black);
/* Initialize the pixel regions. */
gimp_pixel_rgn_init (&src_rgn, drawable, x1, y1, width, height, FALSE, FALSE);
if (preview)
{
pr = gimp_pixel_rgns_register (1, &src_rgn);
preview_buffer = g_new (guchar, width * height * bytes);
}
else
{
gimp_pixel_rgn_init (&dest_rgn, drawable,
x1, y1, width, height, TRUE, TRUE);
pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
}
while (pr)
{
guchar *src_ptr = src_rgn.data;
guchar *dest_ptr;
guchar *blur_ptr = dest1 + (src_rgn.y - y1) * width + (src_rgn.x - x1);
guchar *avg_ptr = dest2 + (src_rgn.y - y1) * width + (src_rgn.x - x1);
gdouble diff;
gdouble mult = 0.0;
gdouble lightness;
if (preview)
dest_ptr =
preview_buffer +
((src_rgn.y - y1) * width + (src_rgn.x - x1)) * bytes;
else
dest_ptr = dest_rgn.data;
for (row = 0; row < src_rgn.h; row++)
{
for (col = 0; col < src_rgn.w; col++)
{
if (avg_ptr[col] != 0)
{
diff = (gdouble) blur_ptr[col] / (gdouble) avg_ptr[col];
if (diff < cvals.threshold)
{
if (ramp == 0.0)
mult = 0.0;
else
mult = (ramp - MIN (ramp, (cvals.threshold - diff))) / ramp;
}
else
mult = 1.0;
}
lightness = CLAMP (blur_ptr[col] * mult, 0, 255);
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
{
/* Convert to HLS, set lightness and convert back */
gint r, g, b;
r = src_ptr[col * src_rgn.bpp + 0];
g = src_ptr[col * src_rgn.bpp + 1];
b = src_ptr[col * src_rgn.bpp + 2];
gimp_rgb_to_hsl_int (&r, &g, &b);
b = lightness;
gimp_hsl_to_rgb_int (&r, &g, &b);
dest_ptr[col * bytes + 0] = r;
dest_ptr[col * bytes + 1] = g;
dest_ptr[col * bytes + 2] = b;
if (has_alpha)
dest_ptr[col * bytes + 3] = src_ptr[col * src_rgn.bpp + 3];
}
}
src_ptr += src_rgn.rowstride;
if (preview)
dest_ptr += width * bytes;
else
dest_ptr += dest_rgn.rowstride;
blur_ptr += width;
avg_ptr += width;
}
if (!preview)
{
progress += src_rgn.w * src_rgn.h;
gimp_progress_update ((gdouble) progress / (gdouble) max_progress);
}
pr = gimp_pixel_rgns_process (pr);
}
if (preview)
{
gimp_preview_draw_buffer (preview, preview_buffer, width * bytes);
g_free (preview_buffer);
}
else
{
/* merge the shadow, update the drawable */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, width, height);
}
/* free up buffers */
g_free (val_p1);
g_free (val_p2);
g_free (val_m1);
g_free (val_m2);
g_free (src);
g_free (dest1);
g_free (dest2);
}
static void
mblur_zoom (GimpDrawable *drawable,
GimpPreview *preview,
gint x1,
gint y1,
gint width,
gint height)
{
GimpPixelRgn dest_rgn;
GimpPixelFetcher *pft;
gpointer pr;
GimpRGB background;
gdouble center_x;
gdouble center_y;
guchar *dest, *d;
guchar pixel[4];
guchar p1[4], p2[4], p3[4], p4[4];
gint32 sum[4];
gint progress, max_progress;
gint x, y, i, n, p, c;
gdouble xx_start, xx_end, yy_start, yy_end;
gdouble xx, yy;
gdouble dxx, dyy;
gdouble dx, dy;
gint xy_len;
gdouble f, r;
gint drawable_x1, drawable_y1;
gint drawable_x2, drawable_y2;
/* initialize */
xx = 0.0;
yy = 0.0;
center_x = mbvals.center_x;
center_y = mbvals.center_y;
gimp_drawable_mask_bounds (drawable->drawable_id,
&drawable_x1, &drawable_y1,
&drawable_x2, &drawable_y2);
gimp_pixel_rgn_init (&dest_rgn, drawable,
x1, y1, width, height, (preview == NULL), TRUE);
pft = gimp_pixel_fetcher_new (drawable, FALSE);
gimp_context_get_background (&background);
gimp_pixel_fetcher_set_bg_color (pft, &background);
progress = 0;
max_progress = width * height;
n = mbvals.length;
if (n == 0)
n = 1;
r = sqrt (SQR (drawable->width / 2) + SQR (drawable->height / 2));
n = ((gdouble) n * r / MBLUR_LENGTH_MAX);
f = (r-n)/r;
for (pr = gimp_pixel_rgns_register (1, &dest_rgn), p = 0;
pr != NULL;
pr = gimp_pixel_rgns_process (pr), p++)
{
dest = dest_rgn.data;
for (y = dest_rgn.y; y < dest_rgn.y + dest_rgn.h; y++)
{
d = dest;
for (x = dest_rgn.x; x < dest_rgn.x + dest_rgn.w; x++)
{
for (c = 0; c < img_bpp; c++)
sum[c] = 0;
xx_start = x;
yy_start = y;
if (mbvals.blur_outward)
{
xx_end = center_x + ((gdouble) x - center_x) * f;
yy_end = center_y + ((gdouble) y - center_y) * f;
}
else
{
xx_end = center_x + ((gdouble) x - center_x) * (1.0/f);
yy_end = center_y + ((gdouble) y - center_y) * (1.0/f);
}
xy_len = sqrt (SQR (xx_end-xx_start) + SQR (yy_end-yy_start)) + 1;
if (xy_len < 3)
xy_len = 3;
dxx = (xx_end - xx_start) / (gdouble) xy_len;
dyy = (yy_end - yy_start) / (gdouble) xy_len;
xx = xx_start;
yy = yy_start;
for (i = 0; i < xy_len; i++)
{
if ((yy < drawable_y1) || (yy >= drawable_y2) ||
(xx < drawable_x1) || (xx >= drawable_x2))
break;
if ((xx+1 < drawable_x2) && (yy+1 < drawable_y2))
{
dx = xx - floor (xx);
dy = yy - floor (yy);
gimp_pixel_fetcher_get_pixel (pft, xx, yy, p1);
gimp_pixel_fetcher_get_pixel (pft, xx+1, yy, p2);
gimp_pixel_fetcher_get_pixel (pft, xx, yy+1, p3);
gimp_pixel_fetcher_get_pixel (pft, xx+1, yy+1, p4);
for (c = 0; c < img_bpp; c++)
{
pixel[c] = (((gdouble)p1[c] * (1.0-dx) +
(gdouble)p2[c] * dx) * (1.0-dy) +
((gdouble)p3[c] * (1.0-dx) +
(gdouble)p4[c] * dx) * dy);
}
}
else
{
gimp_pixel_fetcher_get_pixel (pft, xx+.5, yy+.5, pixel);
}
if (has_alpha)
{
gint32 alpha = pixel[img_bpp-1];
sum[img_bpp-1] += alpha;
for (c = 0; c < img_bpp-1; c++)
sum[c] += pixel[c] * alpha;
}
else
{
for (c = 0; c < img_bpp; c++)
sum[c] += pixel[c];
}
xx += dxx;
yy += dyy;
}
if (i == 0)
{
gimp_pixel_fetcher_get_pixel (pft, xx, yy, d);
}
else
{
if (has_alpha)
{
gint32 alpha = sum[img_bpp-1];
if ((d[img_bpp-1] = alpha/i) != 0)
{
for (c = 0; c < img_bpp-1; c++)
d[c] = sum[c] / alpha;
}
}
else
{
for (c = 0; c < img_bpp; c++)
d[c] = sum[c] / i;
}
}
d += dest_rgn.bpp;
}
dest += dest_rgn.rowstride;
}
if (preview)
{
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview),
&dest_rgn);
}
else
{
progress += dest_rgn.w * dest_rgn.h;
if ((p % 8) == 0)
gimp_progress_update ((gdouble) progress / max_progress);
}
}
gimp_pixel_fetcher_destroy (pft);
}
/*
* 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 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 x1, y1;
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, &x1, &y1);
gimp_preview_get_size (preview, &width, &height);
}
else
{
gint x2, y2;
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = x2 - x1;
height = y2 - y1;
}
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,
x1, y1, 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 - y1) * width + (src_rgn.x - x1);
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, x1, y1, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&dest_rgn, drawable, x1, y1, 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 - y1) * width + (src_rgn.x - x1);
guchar *avg_ptr = dest2 + (src_rgn.y - y1) * width + (src_rgn.x - x1);
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)
{
/* merge the shadow, update the drawable */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, 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);
}
/*
This function operates on the image when pixelwidth >= tile_width.
It simply sets the size of GimpPixelRgn as pixelwidth and proceeds.
*/
static void
pixelize_large (GimpDrawable *drawable,
gint pixelwidth,
gint pixelheight,
GimpPreview *preview)
{
GimpPixelRgn src_rgn, dest_rgn;
guchar *src_row, *dest_row;
guchar *src, *dest = NULL, *d;
gulong average[4];
gint row, col, b, bpp, has_alpha;
gint x, y, x_step, y_step;
gint i, j;
gulong count;
gint x1, y1, x2, y2;
gint width, height;
gint progress = 0, max_progress = 1;
gpointer pr;
bpp = gimp_drawable_bpp (drawable->drawable_id);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
if (preview)
{
gimp_preview_get_position (preview, &x1, &y1);
gimp_preview_get_size (preview, &width, &height);
x2 = x1 + width;
y2 = y1 + height;
dest = g_new (guchar, width * height * bpp);
}
else
{
gimp_drawable_mask_bounds (drawable->drawable_id,
&x1, &y1, &x2, &y2);
width = x2 - x1;
height = y2 - y1;
/* Initialize progress */
progress = 0;
max_progress = 2 * width * height;
}
for (y = y1; y < y2; y += pixelheight - (y % pixelheight))
{
for (x = x1; x < x2; x += pixelwidth - (x % pixelwidth))
{
x_step = pixelwidth - (x % pixelwidth);
y_step = pixelheight - (y % pixelheight);
x_step = MIN (x_step, x2 - x);
y_step = MIN (y_step, y2 - y);
gimp_pixel_rgn_init (&src_rgn, drawable,
x, y, x_step, y_step, FALSE, FALSE);
for (b = 0; b < bpp; b++)
average[b] = 0;
count = 0;
for (pr = gimp_pixel_rgns_register (1, &src_rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
src_row = src_rgn.data;
for (row = 0; row < src_rgn.h; row++)
{
src = src_row;
if (has_alpha)
{
for (col = 0; col < src_rgn.w; col++)
{
gulong alpha = src[bpp - 1];
average[bpp - 1] += alpha;
for (b = 0; b < bpp - 1; b++)
average[b] += src[b] * alpha;
src += src_rgn.bpp;
}
}
else
{
for (col = 0; col < src_rgn.w; col++)
{
for (b = 0; b < bpp; b++)
average[b] += src[b];
src += src_rgn.bpp;
}
}
src_row += src_rgn.rowstride;
}
count += src_rgn.w * src_rgn.h;
if (!preview)
{
/* Update progress */
progress += src_rgn.w * src_rgn.h;
gimp_progress_update ((double) progress / (double) max_progress);
}
}
if (count > 0)
{
if (has_alpha)
{
gulong alpha = average[bpp - 1];
if ((average[bpp - 1] = alpha / count))
for (b = 0; b < bpp - 1; b++)
average[b] /= alpha;
}
else
{
for (b = 0; b < bpp; b++)
average[b] /= count;
}
}
if (preview)
{
dest_row = dest + ((y - y1) * width + (x - x1)) * bpp;
for (j = 0; j < y_step; j++)
{
d = dest_row;
for (i = 0; i < x_step; i++)
for (b = 0; b < bpp; b++)
*d++ = average[b];
dest_row += width * bpp;
}
}
else
{
gimp_pixel_rgn_init (&dest_rgn, drawable,
x, y, x_step, y_step,
TRUE, TRUE);
for (pr = gimp_pixel_rgns_register (1, &dest_rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
dest_row = dest_rgn.data;
for (row = 0; row < dest_rgn.h; row++)
{
dest = dest_row;
for (col = 0; col < dest_rgn.w; col++)
{
for (b = 0; b < bpp; b++)
dest[b] = average[b];
dest += dest_rgn.bpp;
}
dest_row += dest_rgn.rowstride;
}
/* Update progress */
progress += dest_rgn.w * dest_rgn.h;
gimp_progress_update ((double) progress / (double) max_progress);
}
}
}
}
if (preview)
{
gimp_preview_draw_buffer (preview, dest, width * bpp);
g_free (dest);
}
else
{
/* update the blurred 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
gauss_rle (GimpDrawable *drawable,
gdouble radius,
gint pass,
gboolean show_progress)
{
GimpPixelRgn src_rgn, dest_rgn;
gint width, height;
gint bytes;
gint has_alpha;
guchar *dest, *dp;
guchar *src, *sp;
gint *buf, *bb;
gint pixels;
gint total = 1;
gint x1, y1, x2, y2;
gint i, row, col, b;
gint start, end;
gdouble progress, max_progress;
gint *curve;
gint *sum = NULL;
gint val;
gint length;
gint initial_p, initial_m;
gdouble std_dev;
if (radius <= 0.0)
return;
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = (x2 - x1);
height = (y2 - y1);
if (width < 1 || height < 1)
return;
bytes = drawable->bpp;
has_alpha = gimp_drawable_has_alpha(drawable->drawable_id);
buf = g_new (gint, MAX (width, height) * 2);
/* allocate buffers for source and destination pixels */
src = g_new (guchar, MAX (width, height) * bytes);
dest = g_new (guchar, MAX (width, height) * bytes);
gimp_pixel_rgn_init (&src_rgn,
drawable, 0, 0, drawable->width, drawable->height,
FALSE, FALSE);
gimp_pixel_rgn_init (&dest_rgn,
drawable, 0, 0, drawable->width, drawable->height,
TRUE, TRUE);
progress = 0.0;
max_progress = 2 * width * height;
/* First the vertical pass */
radius = fabs (radius) + 1.0;
std_dev = sqrt (-(radius * radius) / (2 * log (1.0 / 255.0)));
curve = make_curve (std_dev, &length);
sum = g_new (gint, 2 * length + 1);
sum[0] = 0;
for (i = 1; i <= length*2; i++)
sum[i] = curve[i-length-1] + sum[i-1];
sum += length;
total = sum[length] - sum[-length];
for (col = 0; col < width; col++)
{
gimp_pixel_rgn_get_col (&src_rgn, src, col + x1, y1, (y2 - y1));
if (has_alpha)
multiply_alpha (src, height, bytes);
sp = src;
dp = dest;
for (b = 0; b < bytes; b++)
{
initial_p = sp[b];
initial_m = sp[(height-1) * bytes + b];
/* Determine a run-length encoded version of the row */
run_length_encode (sp + b, buf, bytes, height);
for (row = 0; row < height; row++)
{
start = (row < length) ? -row : -length;
end = (height <= (row + length) ?
(height - row - 1) : length);
val = 0;
i = start;
bb = buf + (row + i) * 2;
if (start != -length)
val += initial_p * (sum[start] - sum[-length]);
while (i < end)
{
pixels = bb[0];
i += pixels;
if (i > end)
i = end;
val += bb[1] * (sum[i] - sum[start]);
bb += (pixels * 2);
start = i;
}
if (end != length)
val += initial_m * (sum[length] - sum[end]);
dp[row * bytes + b] = val / total;
}
}
if (has_alpha)
separate_alpha (dest, height, bytes);
gimp_pixel_rgn_set_col (&dest_rgn, dest, col + x1, y1, (y2 - y1));
if (show_progress)
{
progress += height;
if ((col % 32) == 0)
gimp_progress_update (0.5 * (pass + (progress / max_progress)));
}
}
/* prepare for the horizontal pass */
gimp_pixel_rgn_init (&src_rgn,
drawable, 0, 0, drawable->width, drawable->height,
FALSE, TRUE);
/* Now the horizontal pass */
for (row = 0; row < height; row++)
{
gimp_pixel_rgn_get_row (&src_rgn, src, x1, row + y1, (x2 - x1));
if (has_alpha)
multiply_alpha (src, width, bytes);
sp = src;
dp = dest;
for (b = 0; b < bytes; b++)
{
initial_p = sp[b];
initial_m = sp[(width-1) * bytes + b];
/* Determine a run-length encoded version of the row */
run_length_encode (sp + b, buf, bytes, width);
for (col = 0; col < width; col++)
{
start = (col < length) ? -col : -length;
end = (width <= (col + length)) ? (width - col - 1) : length;
val = 0;
i = start;
bb = buf + (col + i) * 2;
if (start != -length)
val += initial_p * (sum[start] - sum[-length]);
while (i < end)
{
pixels = bb[0];
i += pixels;
if (i > end)
i = end;
val += bb[1] * (sum[i] - sum[start]);
bb += (pixels * 2);
start = i;
}
if (end != length)
val += initial_m * (sum[length] - sum[end]);
dp[col * bytes + b] = val / total;
}
}
if (has_alpha)
separate_alpha (dest, width, bytes);
gimp_pixel_rgn_set_row (&dest_rgn, dest, x1, row + y1, (x2 - x1));
if (show_progress)
{
progress += width;
if ((row % 32) == 0)
gimp_progress_update (0.5 * (pass + (progress / max_progress)));
}
}
/* merge the shadow, update the drawable */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
/* free buffers */
g_free (buf);
g_free (src);
g_free (dest);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
gint32 image_ID;
GimpRunMode run_mode;
gint pwidth;
gint pheight;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint sel_width;
gint sel_height;
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 specified drawable */
drawable = gimp_drawable_get (param[2].data.d_drawable);
image_ID = param[1].data.d_image;
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
/* Calculate preview size */
if (sel_width > sel_height)
{
pwidth = MIN (sel_width, PREVIEW_SIZE);
pheight = sel_height * pwidth / sel_width;
}
else
{
pheight = MIN (sel_height, PREVIEW_SIZE);
pwidth = sel_width * pheight / sel_height;
}
preview_width = MAX (pwidth, 2);
preview_height = MAX (pheight, 2);
/* See how we will run */
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data ("plug_in_fractalexplorer", &wvals);
/* Get information from the dialog */
if (!explorer_dialog ())
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are present */
if (nparams != 22)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
wvals.fractaltype = param[3].data.d_int8;
wvals.xmin = param[4].data.d_float;
wvals.xmax = param[5].data.d_float;
wvals.ymin = param[6].data.d_float;
wvals.ymax = param[7].data.d_float;
wvals.iter = param[8].data.d_float;
wvals.cx = param[9].data.d_float;
wvals.cy = param[10].data.d_float;
wvals.colormode = param[11].data.d_int8;
wvals.redstretch = param[12].data.d_float;
wvals.greenstretch = param[13].data.d_float;
wvals.bluestretch = param[14].data.d_float;
wvals.redmode = param[15].data.d_int8;
wvals.greenmode = param[16].data.d_int8;
wvals.bluemode = param[17].data.d_int8;
wvals.redinvert = param[18].data.d_int8;
wvals.greeninvert = param[19].data.d_int8;
wvals.blueinvert = param[20].data.d_int8;
wvals.ncolors = CLAMP (param[21].data.d_int32, 2, MAXNCOLORS);
}
make_color_map();
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data ("plug_in_fractalexplorer", &wvals);
make_color_map ();
break;
default:
break;
}
xmin = wvals.xmin;
xmax = wvals.xmax;
ymin = wvals.ymin;
ymax = wvals.ymax;
cx = wvals.cx;
cy = wvals.cy;
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is not indexed */
if (! gimp_drawable_is_indexed (drawable->drawable_id))
{
gimp_progress_init (_("Rendering fractal"));
/* Set the tile cache size */
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width() + 1));
/* Run! */
explorer (drawable);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data ("plug_in_fractalexplorer",
&wvals, sizeof (explorer_vals_t));
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
values[0].data.d_status = status;
gimp_drawable_detach (drawable);
}
static void
sobel (GimpDrawable *drawable,
gboolean do_horizontal,
gboolean do_vertical,
gboolean keep_sign,
GimpPreview *preview)
{
GimpPixelRgn srcPR, destPR;
gint width, height;
gint bytes;
gint gradient, hor_gradient, ver_gradient;
guchar *dest, *d;
guchar *prev_row, *pr;
guchar *cur_row, *cr;
guchar *next_row, *nr;
guchar *tmp;
gint row, col;
gint x1, y1, x2, y2;
gboolean alpha;
gint counter;
guchar *preview_buffer = NULL;
if (preview)
{
gimp_preview_get_position (preview, &x1, &y1);
gimp_preview_get_size (preview, &width, &height);
x2 = x1 + width;
y2 = y1 + height;
}
else
{
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_progress_init (_("Sobel edge detecting"));
width = x2 - x1;
height = y2 - y1;
}
/* Get the size of the input image. (This will/must be the same
* as the size of the output image.
*/
bytes = drawable->bpp;
alpha = gimp_drawable_has_alpha (drawable->drawable_id);
/* 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, 0, 0,
drawable->width, drawable->height,
FALSE, FALSE);
if (preview)
{
preview_buffer = g_new (guchar, width * height * bytes);
}
else
{
gimp_pixel_rgn_init (&destPR, drawable, 0, 0,
drawable->width, drawable->height,
TRUE, TRUE);
}
pr = prev_row + bytes;
cr = cur_row + bytes;
nr = next_row + bytes;
sobel_prepare_row (&srcPR, pr, x1, y1 - 1, width);
sobel_prepare_row (&srcPR, cr, x1, y1, width);
counter =0;
/* loop through the rows, applying the sobel convolution */
for (row = y1; row < y2; row++)
{
/* prepare the next row */
sobel_prepare_row (&srcPR, nr, x1, row + 1, width);
d = dest;
for (col = 0; col < width * bytes; col++)
{
hor_gradient = (do_horizontal ?
((pr[col - bytes] + 2 * pr[col] + pr[col + bytes]) -
(nr[col - bytes] + 2 * nr[col] + nr[col + bytes]))
: 0);
ver_gradient = (do_vertical ?
((pr[col - bytes] + 2 * cr[col - bytes] + nr[col - bytes]) -
(pr[col + bytes] + 2 * cr[col + bytes] + nr[col + bytes]))
: 0);
gradient = (do_vertical && do_horizontal) ?
(ROUND (RMS (hor_gradient, ver_gradient)) / 5.66) /* always >0 */
: (keep_sign ? (127 + (ROUND ((hor_gradient + ver_gradient) / 8.0)))
: (ROUND (abs (hor_gradient + ver_gradient) / 4.0)));
if (alpha && (((col + 1) % bytes) == 0))
{ /* the alpha channel */
*d++ = (counter == 0) ? 0 : 255;
counter = 0;
}
else
{
*d++ = gradient;
if (gradient > 10) counter ++;
}
}
/* shuffle the row pointers */
tmp = pr;
pr = cr;
cr = nr;
nr = tmp;
/* store the dest */
if (preview)
{
memcpy (preview_buffer + width * (row - y1) * bytes,
dest,
width * bytes);
}
else
{
gimp_pixel_rgn_set_row (&destPR, dest, x1, row, width);
if ((row % 20) == 0)
gimp_progress_update ((double) row / (double) (y2 - y1));
}
}
if (preview)
{
gimp_preview_draw_buffer (preview, preview_buffer, width * bytes);
g_free (preview_buffer);
}
else
{
gimp_progress_update (1.0);
/* update the sobeled region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, width, height);
}
g_free (prev_row);
g_free (cur_row);
g_free (next_row);
g_free (dest);
}
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, x2, y2;
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);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
bpp = gimp_drawable_bpp (drawable->drawable_id);
ppm_kill (&brushppm);
ppm_new (&brushppm, x2 - x1, y2 - y1);
p = &brushppm;
rowstride = p->width * 3;
src_row = g_new (guchar, (x2 - x1) * bpp);
gimp_pixel_rgn_init (&src_rgn, drawable,
0, 0, x2 - x1, y2 - y1,
FALSE, FALSE);
if (bpp == 3)
{ /* RGB */
int bpr = (x2 - x1) * 3;
for (row = 0, y = y1; y < y2; row++, y++)
{
gimp_pixel_rgn_get_row (&src_rgn, src_row, x1, y, (x2 - x1));
memcpy (p->col + row*rowstride, src_row, bpr);
}
}
else
{ /* RGBA (bpp > 3) GrayA (bpp == 2) or Gray */
gboolean is_gray = ((bpp > 3) ? TRUE : FALSE);
for (row = 0, y = y1; y < y2; row++, y++)
{
guchar *tmprow = p->col + row * rowstride;
guchar *tmprow_ptr;
gimp_pixel_rgn_get_row (&src_rgn, src_row, x1, y, (x2 - x1));
src = src_row;
tmprow_ptr = tmprow;
/* Possible micro-optimization here:
* src_end = src + src_rgn.bpp * (x2-x1);
* 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);
}
static gboolean
pluginCore (piArgs *argp)
{
GimpDrawable *drw, *ndrw = NULL;
GimpPixelRgn srcPr, dstPr;
gboolean success = TRUE;
gint nl = 0;
gint y, i;
gint Y, I, Q;
guint width, height, bpp;
gint sel_x1, sel_x2, sel_y1, sel_y2;
gint prog_interval;
guchar *src, *s, *dst, *d;
guchar r, prev_r=0, new_r=0;
guchar g, prev_g=0, new_g=0;
guchar b, prev_b=0, new_b=0;
gdouble fy, fc, t, scale;
gdouble pr, pg, pb;
gdouble py;
drw = gimp_drawable_get (argp->drawable);
width = drw->width;
height = drw->height;
bpp = drw->bpp;
if (argp->new_layerp)
{
gchar name[40];
const gchar *mode_names[] =
{
"ntsc",
"pal",
};
const gchar *action_names[] =
{
"lum redux",
"sat redux",
"flag",
};
g_snprintf (name, sizeof (name), "hot mask (%s, %s)",
mode_names[argp->mode],
action_names[argp->action]);
nl = gimp_layer_new (argp->image, name, width, height,
GIMP_RGBA_IMAGE, (gdouble)100, GIMP_NORMAL_MODE);
ndrw = gimp_drawable_get (nl);
gimp_drawable_fill (nl, GIMP_TRANSPARENT_FILL);
gimp_image_insert_layer (argp->image, nl, -1, 0);
}
gimp_drawable_mask_bounds (drw->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
width = sel_x2 - sel_x1;
height = sel_y2 - sel_y1;
src = g_new (guchar, width * height * bpp);
dst = g_new (guchar, width * height * 4);
gimp_pixel_rgn_init (&srcPr, drw, sel_x1, sel_y1, width, height,
FALSE, FALSE);
if (argp->new_layerp)
{
gimp_pixel_rgn_init (&dstPr, ndrw, sel_x1, sel_y1, width, height,
FALSE, FALSE);
}
else
{
gimp_pixel_rgn_init (&dstPr, drw, sel_x1, sel_y1, width, height,
TRUE, TRUE);
}
gimp_pixel_rgn_get_rect (&srcPr, src, sel_x1, sel_y1, width, height);
s = src;
d = dst;
build_tab (argp->mode);
gimp_progress_init (_("Hot"));
prog_interval = height / 10;
for (y = sel_y1; y < sel_y2; y++)
{
gint x;
if (y % prog_interval == 0)
gimp_progress_update ((double) y / (double) (sel_y2 - sel_y1));
for (x = sel_x1; x < sel_x2; x++)
{
if (hotp (r = *(s + 0), g = *(s + 1), b = *(s + 2)))
{
if (argp->action == ACT_FLAG)
{
for (i = 0; i < 3; i++)
*d++ = 0;
s += 3;
if (bpp == 4)
*d++ = *s++;
else if (argp->new_layerp)
*d++ = 255;
}
else
{
/*
* Optimization: cache the last-computed hot pixel.
*/
if (r == prev_r && g == prev_g && b == prev_b)
{
*d++ = new_r;
*d++ = new_g;
*d++ = new_b;
s += 3;
if (bpp == 4)
*d++ = *s++;
else if (argp->new_layerp)
*d++ = 255;
}
else
{
Y = tab[0][0][r] + tab[0][1][g] + tab[0][2][b];
I = tab[1][0][r] + tab[1][1][g] + tab[1][2][b];
Q = tab[2][0][r] + tab[2][1][g] + tab[2][2][b];
prev_r = r;
prev_g = g;
prev_b = b;
/*
* Get Y and chroma amplitudes in floating point.
*
* If your C library doesn't have hypot(), just use
* hypot(a,b) = sqrt(a*a, b*b);
*
* Then extract linear (un-gamma-corrected)
* floating-point pixel RGB values.
*/
fy = (double)Y / (double)SCALE;
fc = hypot ((double) I / (double) SCALE,
(double) Q / (double) SCALE);
pr = (double) pix_decode (r);
pg = (double) pix_decode (g);
pb = (double) pix_decode (b);
/*
* Reducing overall pixel intensity by scaling R,
* G, and B reduces Y, I, and Q by the same factor.
* This changes luminance but not saturation, since
* saturation is determined by the chroma/luminance
* ratio.
*
* On the other hand, by linearly interpolating
* between the original pixel value and a grey
* pixel with the same luminance (R=G=B=Y), we
* change saturation without affecting luminance.
*/
if (argp->action == ACT_LREDUX)
{
/*
* Calculate a scale factor that will bring the pixel
* within both chroma and composite limits, if we scale
* luminance and chroma simultaneously.
*
* The calculated chrominance reduction applies
* to the gamma-corrected RGB values that are
* the input to the RGB-to-YIQ operation.
* Multiplying the original un-gamma-corrected
* pixel values by the scaling factor raised to
* the "gamma" power is equivalent, and avoids
* calling gc() and inv_gc() three times each. */
scale = chroma_lim / fc;
t = compos_lim / (fy + fc);
if (t < scale)
scale = t;
scale = pow (scale, mode[argp->mode].gamma);
r = (guint8) pix_encode (scale * pr);
g = (guint8) pix_encode (scale * pg);
b = (guint8) pix_encode (scale * pb);
}
else
{ /* ACT_SREDUX hopefully */
/*
* Calculate a scale factor that will bring the
* pixel within both chroma and composite
* limits, if we scale chroma while leaving
* luminance unchanged.
*
* We have to interpolate gamma-corrected RGB
* values, so we must convert from linear to
* gamma-corrected before interpolation and then
* back to linear afterwards.
*/
scale = chroma_lim / fc;
t = (compos_lim - fy) / fc;
if (t < scale)
scale = t;
pr = gc (pr, argp->mode);
pg = gc (pg, argp->mode);
pb = gc (pb, argp->mode);
py = pr * mode[argp->mode].code[0][0] +
pg * mode[argp->mode].code[0][1] +
pb * mode[argp->mode].code[0][2];
r = pix_encode (inv_gc (py + scale * (pr - py),
argp->mode));
g = pix_encode (inv_gc (py + scale * (pg - py),
argp->mode));
b = pix_encode (inv_gc (py + scale * (pb - py),
argp->mode));
}
*d++ = new_r = r;
*d++ = new_g = g;
*d++ = new_b = b;
s += 3;
if (bpp == 4)
*d++ = *s++;
else if (argp->new_layerp)
*d++ = 255;
}
}
}
else
{
if (!argp->new_layerp)
{
for (i = 0; i < bpp; i++)
*d++ = *s++;
}
else
{
s += bpp;
d += 4;
}
}
}
}
gimp_pixel_rgn_set_rect (&dstPr, dst, sel_x1, sel_y1, width, height);
g_free (src);
g_free (dst);
if (argp->new_layerp)
{
gimp_drawable_flush (ndrw);
gimp_drawable_update (nl, sel_x1, sel_y1, width, height);
}
else
{
gimp_drawable_flush (drw);
gimp_drawable_merge_shadow (drw->drawable_id, TRUE);
gimp_drawable_update (drw->drawable_id, sel_x1, sel_y1, width, height);
}
gimp_displays_flush ();
return success;
}
static void
compute_difference (GimpDrawable *drawable,
GimpDrawable *drawable1,
GimpDrawable *drawable2,
guchar *maxval)
{
GimpPixelRgn src1_rgn, src2_rgn, dest_rgn;
gint width, height;
gint bpp;
gpointer pr;
gint x, y, k;
gint x1, y1, x2, y2;
gboolean has_alpha;
*maxval = 0;
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = (x2 - x1);
height = (y2 - y1);
if (width < 1 || height < 1)
return;
bpp = drawable->bpp;
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
gimp_pixel_rgn_init (&src1_rgn,
drawable1, 0, 0, drawable1->width, drawable1->height,
FALSE, FALSE);
gimp_pixel_rgn_init (&src2_rgn,
drawable2, 0, 0, drawable1->width, drawable1->height,
FALSE, FALSE);
gimp_pixel_rgn_init (&dest_rgn,
drawable, 0, 0, drawable->width, drawable->height,
TRUE, TRUE);
for (pr = gimp_pixel_rgns_register (3, &src1_rgn, &src2_rgn, &dest_rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
guchar *src1 = src1_rgn.data;
guchar *src2 = src2_rgn.data;
guchar *dest = dest_rgn.data;
gint row = src1_rgn.y - y1;
for (y = 0; y < src1_rgn.h; y++, row++)
{
guchar *s1 = src1;
guchar *s2 = src2;
guchar *d = dest;
gint col = src1_rgn.x - x1;
for (x = 0; x < src1_rgn.w; x++, col++)
{
if (has_alpha)
{
for (k = 0; k < bpp-1; k++)
{
d[k] = CLAMP0255 (s1[k] - s2[k]);
*maxval = MAX (d[k], *maxval);
}
}
else
{
for (k = 0; k < bpp; k++)
{
d[k] = CLAMP0255 (s1[k] - s2[k]);
*maxval = MAX (d[k], *maxval);
}
}
s1 += bpp;
s2 += bpp;
d += bpp;
}
src1 += src1_rgn.rowstride;
src2 += src2_rgn.rowstride;
dest += dest_rgn.rowstride;
}
}
}
static void
normalize (GimpDrawable *drawable,
guint maxval)
{
GimpPixelRgn src_rgn, dest_rgn;
gint bpp;
gpointer pr;
gint x, y, k;
gint x1, y1, x2, y2;
gboolean has_alpha;
gdouble factor;
if (maxval == 0)
return;
else
factor = 255.0 / maxval;
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
bpp = drawable->bpp;
has_alpha = gimp_drawable_has_alpha(drawable->drawable_id);
gimp_pixel_rgn_init (&src_rgn,
drawable, 0, 0, drawable->width, drawable->height,
FALSE, FALSE);
gimp_pixel_rgn_init (&dest_rgn,
drawable, 0, 0, drawable->width, drawable->height,
TRUE, TRUE);
for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
guchar *src = src_rgn.data;
guchar *dest = dest_rgn.data;
gint row = src_rgn.y - y1;
for (y = 0; y < src_rgn.h; y++, row++)
{
guchar *s = src;
guchar *d = dest;
gint col = src_rgn.x - x1;
for (x = 0; x < src_rgn.w; x++, col++)
{
if (has_alpha)
{
for (k = 0; k < bpp-1; k++)
d[k] = factor * s[k];
}
else
{
for (k = 0; k < bpp; k++)
d[k] = factor * s[k];
}
s += bpp;
d += bpp;
}
src += src_rgn.rowstride;
dest += dest_rgn.rowstride;
}
}
}
/* - Filter function - I wish all filter functions had a pmode :) */
static void
glasstile (GimpDrawable *drawable,
GimpPreview *preview)
{
GimpPixelRgn srcPR, destPR;
gint width, height;
gint bytes;
guchar *dest, *d;
guchar *cur_row;
gint row, col, i;
gint x1, y1, x2, y2;
/* Translations of variable names from Maswan
* rutbredd = grid width
* ruthojd = grid height
* ymitt = y middle
* xmitt = x middle
*/
gint rutbredd, xpixel1, xpixel2;
gint ruthojd , ypixel2;
gint xhalv, xoffs, xmitt, xplus;
gint yhalv, yoffs, ymitt, yplus;
if (preview)
{
gimp_preview_get_position (preview, &x1, &y1);
gimp_preview_get_size (preview, &width, &height);
x2 = x1 + width;
y2 = y1 + height;
}
else
{
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = x2 - x1;
height = y2 - y1;
}
bytes = drawable->bpp;
cur_row = g_new (guchar, width * bytes);
dest = g_new (guchar, width * bytes);
/* initialize the pixel regions, set grid height/width */
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);
rutbredd = gtvals.xblock;
ruthojd = gtvals.yblock;
xhalv = rutbredd / 2;
yhalv = ruthojd / 2;
xplus = rutbredd % 2;
yplus = ruthojd % 2;
ymitt = y1;
yoffs = 0;
/* Loop through the rows */
for (row = y1; row < y2; row++)
{
d = dest;
ypixel2 = ymitt + yoffs * 2;
ypixel2 = CLAMP (ypixel2, 0, y2 - 1);
gimp_pixel_rgn_get_row (&srcPR, cur_row, x1, ypixel2, width);
yoffs++;
/* if current offset = half, do a displacement next time around */
if (yoffs == yhalv)
{
ymitt += ruthojd;
yoffs = - (yhalv + yplus);
}
xmitt = 0;
xoffs = 0;
for (col = 0; col < x2 - x1; col++) /* one pixel */
{
xpixel1 = (xmitt + xoffs) * bytes;
xpixel2 = (xmitt + xoffs * 2) * bytes;
if (xpixel2 < (x2 - x1) * bytes)
{
if (xpixel2 < 0)
xpixel2 = 0;
for (i = 0; i < bytes; i++)
d[xpixel1 + i] = cur_row[xpixel2 + i];
}
else
{
for (i = 0; i < bytes; i++)
d[xpixel1 + i] = cur_row[xpixel1 + i];
}
xoffs++;
if (xoffs == xhalv)
{
xmitt += rutbredd;
xoffs = - (xhalv + xplus);
}
}
/* Store the dest */
gimp_pixel_rgn_set_row (&destPR, dest, x1, row, width);
if (!preview && ((row % 5) == 0))
{
gimp_progress_update ((gdouble) row / (gdouble) height);
}
}
/* Update region */
if (preview)
{
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview),
&destPR);
}
else
{
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);
}
g_free (cur_row);
g_free (dest);
}
static inline void
filter (void)
{
static void (* overlap)(guchar *, const guchar *);
GimpPixelRgn src;
GimpPixelRgn dst;
GimpRGB color;
guchar pixel[4];
gint division_x;
gint division_y;
gint offset_x;
gint offset_y;
Tile *tiles;
gint numof_tiles;
Tile *t;
gint i;
gint x;
gint y;
gint move_max_pixels;
gint clear_x0;
gint clear_y0;
gint clear_x1;
gint clear_y1;
gint clear_width;
gint clear_height;
guchar *pixels;
guchar *buffer;
gint dindex;
gint sindex;
gint px, py;
GRand *gr;
gr = g_rand_new ();
/* INITIALIZE */
gimp_pixel_rgn_init (&src, p.drawable, 0, 0,
p.drawable->width, p.drawable->height, FALSE, FALSE);
gimp_pixel_rgn_init (&dst, p.drawable, 0, 0,
p.drawable->width, p.drawable->height, TRUE, TRUE);
pixels = g_new (guchar,
p.drawable->bpp * p.drawable->width * p.drawable->height);
buffer = g_new (guchar,
p.drawable->bpp * p.params.tile_width * p.params.tile_height);
overlap = p.drawable_has_alpha ? overlap_RGBA : overlap_RGB;
gimp_progress_init (_("Paper Tile"));
gimp_drawable_mask_bounds (p.drawable->drawable_id,
&p.selection.x0, &p.selection.y0,
&p.selection.x1, &p.selection.y1);
p.selection.width = p.selection.x1 - p.selection.x0;
p.selection.height = p.selection.y1 - p.selection.y0;
gimp_tile_cache_ntiles (2 * (p.selection.width / gimp_tile_width () + 1));
/* TILES */
division_x = p.params.division_x;
division_y = p.params.division_y;
if (p.params.fractional_type == FRACTIONAL_TYPE_FORCE)
{
if (0 < p.drawable->width % p.params.tile_width) division_x++;
if (0 < p.drawable->height % p.params.tile_height) division_y++;
if (p.params.centering)
{
if (1 < p.drawable->width % p.params.tile_width)
{
division_x++;
offset_x =
(p.drawable->width % p.params.tile_width) / 2 -
p.params.tile_width;
}
else
{
offset_x = 0;
}
if (1 < p.drawable->height % p.params.tile_height)
{
division_y++;
offset_y =
(p.drawable->height % p.params.tile_height) / 2 -
p.params.tile_height;
}
else
{
offset_y = 0;
}
}
else
{
offset_x = 0;
offset_y = 0;
}
}
else
{
if (p.params.centering)
{
offset_x = (p.drawable->width % p.params.tile_width) / 2;
offset_y = (p.drawable->height % p.params.tile_height) / 2;
}
else
{
offset_x = 0;
offset_y = 0;
}
}
move_max_pixels = p.params.move_max_rate * p.params.tile_width / 100.0;
numof_tiles = division_x * division_y;
t = tiles = g_new(Tile, numof_tiles);
for (y = 0; y < division_y; y++)
{
gint srcy = offset_y + p.params.tile_height * y;
for (x = 0; x < division_x; x++, t++)
{
gint srcx = offset_x + p.params.tile_width * x;
if (srcx < 0)
{
t->x = 0;
t->width = srcx + p.params.tile_width;
}
else if (srcx + p.params.tile_width < p.drawable->width)
{
t->x = srcx;
t->width = p.params.tile_width;
}
else
{
t->x = srcx;
t->width = p.drawable->width - srcx;
}
if (srcy < 0)
{
t->y = 0;
t->height = srcy + p.params.tile_height;
}
else if (srcy + p.params.tile_height < p.drawable->height)
{
t->y = srcy;
t->height = p.params.tile_height;
}
else
{
t->y = srcy;
t->height = p.drawable->height - srcy;
}
t->z = g_rand_int (gr);
random_move (&t->move_x, &t->move_y, move_max_pixels);
}
}
qsort (tiles, numof_tiles, sizeof *tiles, tile_compare);
gimp_pixel_rgn_get_rect (&src, pixels, 0, 0, p.drawable->width,
p.drawable->height);
if (p.params.fractional_type == FRACTIONAL_TYPE_IGNORE)
{
clear_x0 = offset_x;
clear_y0 = offset_y;
clear_width = p.params.tile_width * division_x;
clear_height = p.params.tile_height * division_y;
}
else
{
clear_x0 = 0;
clear_y0 = 0;
clear_width = p.drawable->width;
clear_height = p.drawable->height;
}
clear_x1 = clear_x0 + clear_width;
clear_y1 = clear_y0 + clear_height;
switch (p.params.background_type)
{
case BACKGROUND_TYPE_TRANSPARENT:
for (y = clear_y0; y < clear_y1; y++)
{
for (x = clear_x0; x < clear_x1; x++)
{
dindex = p.drawable->bpp * (p.drawable->width * y + x);
for (i = 0; i < p.drawable->bpp; i++)
{
pixels[dindex+i] = 0;
}
}
}
break;
case BACKGROUND_TYPE_INVERTED:
for (y = clear_y0; y < clear_y1; y++)
{
for (x = clear_x0; x < clear_x1; x++)
{
dindex = p.drawable->bpp * (p.drawable->width * y + x);
pixels[dindex+0] = 255 - pixels[dindex+0];
pixels[dindex+1] = 255 - pixels[dindex+1];
pixels[dindex+2] = 255 - pixels[dindex+2];
}
}
break;
case BACKGROUND_TYPE_IMAGE:
break;
case BACKGROUND_TYPE_FOREGROUND:
gimp_context_get_foreground (&color);
gimp_rgb_get_uchar (&color, &pixel[0], &pixel[1], &pixel[2]);
pixel[3] = 255;
for (y = clear_y0; y < clear_y1; y++)
{
for (x = clear_x0; x < clear_x1; x++)
{
dindex = p.drawable->bpp * (p.drawable->width * y + x);
for (i = 0; i < p.drawable->bpp; i++)
{
pixels[dindex+i] = pixel[i];
}
}
}
break;
case BACKGROUND_TYPE_BACKGROUND:
gimp_context_get_background (&color);
gimp_rgb_get_uchar (&color, &pixel[0], &pixel[1], &pixel[2]);
pixel[3] = 255;
for (y = clear_y0; y < clear_y1; y++)
{
for (x = clear_x0; x < clear_x1; x++)
{
dindex = p.drawable->bpp * (p.drawable->width * y + x);
for(i = 0; i < p.drawable->bpp; i++)
{
pixels[dindex+i] = pixel[i];
}
}
}
break;
case BACKGROUND_TYPE_COLOR:
gimp_rgba_get_uchar (&p.params.background_color,
pixel, pixel + 1, pixel + 2, pixel + 3);
for (y = clear_y0; y < clear_y1; y++)
{
for (x = clear_x0; x < clear_x1; x++)
{
dindex = p.drawable->bpp * (p.drawable->width * y + x);
for(i = 0; i < p.drawable->bpp; i++)
{
pixels[dindex+i] = pixel[i];
}
}
}
break;
}
/* DRAW */
for (t = tiles, i = 0; i < numof_tiles; i++, t++)
{
gint x0 = t->x + t->move_x;
gint y0 = t->y + t->move_y;
gimp_pixel_rgn_get_rect (&src, buffer, t->x, t->y, t->width, t->height);
for (y = 0; y < t->height; y++)
{
py = y0 + y;
for (x = 0; x < t->width; x++)
{
px = x0 + x;
sindex = p.drawable->bpp * (t->width * y + x);
if (0 <= px && px < p.drawable->width &&
0 <= py && py < p.drawable->height)
{
dindex = p.drawable->bpp * (p.drawable->width * py + px);
overlap(&pixels[dindex], &buffer[sindex]);
}
else if (p.params.wrap_around)
{
px = (px + p.drawable->width) % p.drawable->width;
py = (py + p.drawable->height) % p.drawable->height;
dindex = p.drawable->bpp * (p.drawable->width * py + px);
overlap(&pixels[dindex], &buffer[sindex]);
}
}
}
gimp_progress_update ((gdouble) i / (gdouble) numof_tiles);
}
gimp_pixel_rgn_set_rect (&dst, pixels, 0, 0, p.drawable->width,
p.drawable->height);
gimp_progress_update (1.0);
gimp_drawable_flush (p.drawable);
gimp_drawable_merge_shadow (p.drawable->drawable_id, TRUE);
gimp_drawable_update (p.drawable->drawable_id,
p.selection.x0, p.selection.y0,
p.selection.width, p.selection.height);
g_rand_free (gr);
g_free (buffer);
g_free (pixels);
g_free (tiles);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpRunMode run_mode;
GimpPDBStatusType status;
GimpDrawable *drawable;
gint x1, y1, x2, y2;
INIT_I18N ();
status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
/* 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_bpp = gimp_drawable_bpp (drawable->drawable_id);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
mbvals.center_x = (gdouble) (x1 + x2 - 1) / 2.0;
mbvals.center_y = (gdouble) (y1 + y2 - 1) / 2.0;
/* Set the tile cache size */
gimp_tile_cache_ntiles (2 * drawable->ntile_cols);
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &mbvals);
/* Get information from the dialog */
if (! mblur_dialog (param[1].data.d_image, drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
if (strcmp (name, PLUG_IN_PROC_INWARD) == 0)
mbvals.blur_outward = FALSE;
if (nparams == 8)
{
mbvals.center_x = param[6].data.d_float;
mbvals.center_y = param[7].data.d_float;
}
else if (nparams != 6)
{
status = GIMP_PDB_CALLING_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
mbvals.mblur_type = param[3].data.d_int32;
mbvals.length = param[4].data.d_int32;
mbvals.angle = param[5].data.d_int32;
}
if ((mbvals.mblur_type < 0) || (mbvals.mblur_type > MBLUR_MAX))
status= GIMP_PDB_CALLING_ERROR;
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &mbvals);
break;
default:
break;
}
/* Blur the image */
if ((status == GIMP_PDB_SUCCESS) &&
(gimp_drawable_is_rgb(drawable->drawable_id) ||
gimp_drawable_is_gray(drawable->drawable_id)))
{
/* Run! */
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
mblur (drawable, NULL);
/* 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, &mbvals, sizeof (mblur_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
explorer (GimpDrawable * drawable)
{
GimpPixelRgn srcPR;
GimpPixelRgn destPR;
gint width;
gint height;
gint bpp;
gint row;
gint x1;
gint y1;
gint x2;
gint y2;
guchar *src_row;
guchar *dest_row;
/* Get the input area. This is the bounding box of the selection in
* the image (or the entire image if there is no selection). Only
* operating on the input area is simply an optimization. It doesn't
* need to be done for correct operation. (It simply makes it go
* faster, since fewer pixels need to be operated on).
*/
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
/* 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;
/* allocate row buffers */
src_row = g_new (guchar, bpp * (x2 - x1));
dest_row = g_new (guchar, bpp * (x2 - x1));
/* initialize the pixel regions */
gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&destPR, drawable, 0, 0, width, height, TRUE, TRUE);
xbild = width;
ybild = height;
xdiff = (xmax - xmin) / xbild;
ydiff = (ymax - ymin) / ybild;
/* for grayscale drawables */
if (bpp < 3)
{
gint i;
for (i = 0; i < MAXNCOLORS; i++)
valuemap[i] = GIMP_RGB_LUMINANCE (colormap[i].r,
colormap[i].g,
colormap[i].b);
}
for (row = y1; row < y2; row++)
{
gimp_pixel_rgn_get_row (&srcPR, src_row, x1, row, (x2 - x1));
explorer_render_row (src_row,
dest_row,
row,
(x2 - x1),
bpp);
/* store the dest */
gimp_pixel_rgn_set_row (&destPR, dest_row, x1, row, (x2 - x1));
if ((row % 10) == 0)
gimp_progress_update ((double) row / (double) (y2 - y1));
}
/* update the processed region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
g_free (src_row);
g_free (dest_row);
}
static void
exponentialrange (GimpDrawable *drawable)
{
gint i, j, k, channels;
gint x1, y1, x2, y2;
GimpPixelRgn rgn_in, rgn_out;
guchar output[4];
/* Gets upper left and lower right coordinates,
* and layers number in the image */
gimp_drawable_mask_bounds (drawable->drawable_id,
&x1, &y1,
&x2, &y2);
channels = gimp_drawable_bpp (drawable->drawable_id);
/* Initialises two PixelRgns, one to read original data,
* and the other to write output data. That second one will
* be merged at the end by the call to
* gimp_drawable_merge_shadow() */
gimp_pixel_rgn_init (&rgn_in,
drawable,
x1, y1,
x2 - x1, y2 - y1,
FALSE, FALSE);
gimp_pixel_rgn_init (&rgn_out,
drawable,
x1, y1,
x2 - x1, y2 - y1,
TRUE, TRUE);
/* find the range [minp,maxp] */
guchar minp[4],maxp[4];
/* initial values are high for minp, low for maxp*/
for (j = 0; j < 4; j++){
minp[j]=255; // default for guchar 0..255
maxp[j]=0;
}
/* get the right range */
for (i = x1; i < x2; i++){
for (j = y1; j < y2; j++){
guchar pixel[4];
gimp_pixel_rgn_get_pixel (&rgn_in, pixel, i, j);
for (k = 0; k < channels; k++){
if(minp[k]>pixel[k]) minp[k]=pixel[k];
if(maxp[k]<pixel[k]) maxp[k]=pixel[k];
}
}
}
for (i = x1; i < x2; i++)
{
for (j = y1; j < y2; j++)
{
guchar pixel[4];
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel, /*[4]*/
i, j);
/* For each layer, compute the exponential in the same range */
for (k = 0; k < channels; k++)
{
double ex = exp(pixel[k])- exp(minp[k]);
double ran=exp(maxp[k])-exp(minp[k]);
output[k] = (guchar)( minp[k] + (maxp[k]-minp[k]) * (ex/ran) );
}
gimp_pixel_rgn_set_pixel (&rgn_out,
output,
i, j);
} /*end for j*/
if (i % 10 == 0)
gimp_progress_update ((gdouble) (i - x1) / (gdouble) (x2 - x1));
} /*end for i*/
/* Update the modified region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
x1, y1,
x2 - x1, y2 - y1);
}
