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);
}
/* ----------------------------------------
* p_subtract_ref_layer
* ----------------------------------------
* setup pixel regions and perform edge detection by subtracting RGB channels
* of the orignal (refDrawable) from the blurred copy (edgeDrawable)
* and convert the rgb differences to lightness.
*
* as result of this processing in the edgeDrawable contains a desaturated
* colordifference of the original versus blured copy.
*/
static void
p_subtract_ref_layer(gint32 image_id, GimpDrawable *edgeDrawable, GimpDrawable *refDrawable
, gdouble threshold, gint32 shift, gboolean invert)
{
GimpPixelRgn edgePR;
GimpPixelRgn refPR;
GimpPixelRgn ref2PR;
gpointer pr;
gdouble threshold01f;
gdouble threshold255f;
gint threshold255;
gint cx;
gint cy;
threshold01f = CLAMP((threshold / 100.0), 0, 1);
threshold255f = 255.0 * threshold01f;
threshold255 = threshold255f;
p_get_debug_coords_from_guides(image_id, &cx, &cy);
gimp_pixel_rgn_init (&edgePR, edgeDrawable, 0, 0
, edgeDrawable->width - shift, edgeDrawable->height - shift
, TRUE /* dirty */
, FALSE /* shadow */
);
/* start at shifted offset 0/+1 */
gimp_pixel_rgn_init (&refPR, refDrawable, 0, shift
, refDrawable->width - shift, refDrawable->height - shift
, FALSE /* dirty */
, FALSE /* shadow */
);
/* start at shifted offset +1/0 */
gimp_pixel_rgn_init (&ref2PR, refDrawable, shift, 0
, refDrawable->width - shift, refDrawable->height - shift
, FALSE /* dirty */
, FALSE /* shadow */
);
/* compare pixel areas in tiled portions via pixel region processing loops.
*/
for (pr = gimp_pixel_rgns_register (3, &edgePR, &refPR, &ref2PR);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
p_colordiffProcessingForOneRegion (&edgePR, &refPR, &ref2PR, threshold01f, invert, cx, cy);
}
gimp_drawable_flush (edgeDrawable);
gimp_drawable_update (edgeDrawable->drawable_id
, 0, 0
, edgeDrawable->width, edgeDrawable->height
);
} /* end p_subtract_ref_layer */
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);
}
}
// !!! Note GIMP abbreviates Rgn instead of region, and gimp_ prefix to functions
// Compare to plug-ins/pygimp/pygimp-tile.c
static gboolean
process (GeglOperation *operation,
GeglBuffer *data,
const GeglRectangle *result)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
g_printf("Process sink\n");
if (! o->drawableID)
return FALSE;
else
{
GimpDrawable *drawable;
const Babl *format;
GimpPixelRgn io_pixel_region;
gpointer pr;
g_printf("result width %d\n", result->width);
drawable = gimp_drawable_get(o->drawableID);
// format = gegl_operation_get_format (operation, "output");
format = babl_format ("RGBA u8");
// TODO test format of operation with format of drawable
gimp_pixel_rgn_init (&io_pixel_region, drawable,
result->x, result->y,
result->width, result->height,
TRUE, TRUE);
for (pr = gimp_pixel_rgns_register (1, &io_pixel_region);
pr;
pr = gimp_pixel_rgns_process (pr))
{
GeglRectangle rect = { io_pixel_region.x, io_pixel_region.y, io_pixel_region.w, io_pixel_region.h };
gegl_buffer_get (data, GIMP_SINK_SCALE, &rect, format, io_pixel_region.data, io_pixel_region.rowstride);
}
/*
Drawable is set of tiles private to this sink.
Not the same as the caller's, nor the same as the source node's.
*/
gimp_drawable_flush(drawable);
gimp_drawable_merge_shadow(o->drawableID, FALSE);
gimp_drawable_update(o->drawableID, result->x, result->y,
result->width, result->height);
return TRUE;
}
}
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));
}
/*
* 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);
}
// !!! Note GIMP abbreviates Rgn instead of region, and gimp_ prefix to functions
// Compare to plug-ins/pygimp/pygimp-tile.c
static gboolean
process (GeglOperation *operation,
GeglBuffer *data,
const GeglRectangle *result)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
g_printf("Process\n");
if (! o->drawableID)
return FALSE;
else
{
GimpDrawable *drawable;
const Babl *format;
GimpPixelRgn io_pixel_region;
gpointer pr;
g_printf("result width %d\n", result->width);
drawable = gimp_drawable_get(o->drawableID);
// drawable = o->drawableID;
// format = gegl_operation_get_format (operation, "output");
format = babl_format ("RGBA u8");
gimp_pixel_rgn_init (&io_pixel_region, drawable,
result->x, result->y,
result->width, result->height,
FALSE, FALSE);
for (pr = gimp_pixel_rgns_register (1, &io_pixel_region);
pr;
pr = gimp_pixel_rgns_process (pr))
{
GeglRectangle rect = { io_pixel_region.x, io_pixel_region.y, io_pixel_region.w, io_pixel_region.h };
gegl_buffer_set (data, &rect, format, io_pixel_region.data, io_pixel_region.rowstride);
}
return TRUE;
}
}
static void
gimp_rgn_iterator_iter_single (GimpRgnIterator *iter,
GimpPixelRgn *srcPR,
GimpRgnFuncSrc func,
gpointer data)
{
gpointer pr;
gint total_area;
gint area_so_far;
total_area = (iter->x2 - iter->x1) * (iter->y2 - iter->y1);
area_so_far = 0;
for (pr = gimp_pixel_rgns_register (1, srcPR);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
guchar *src = srcPR->data;
gint y;
for (y = srcPR->y; y < srcPR->y + srcPR->h; y++)
{
guchar *s = src;
gint x;
for (x = srcPR->x; x < srcPR->x + srcPR->w; x++)
{
func (x, y, s, srcPR->bpp, data);
s += srcPR->bpp;
}
src += srcPR->rowstride;
}
area_so_far += srcPR->w * srcPR->h;
gimp_progress_update ((gdouble) area_so_far / (gdouble) total_area);
}
}
/* ----------------------------------------
* p_edgeDetection
* ----------------------------------------
* setup pixel regions and perform edge detection processing per region.
* as result of this processing the edgeDrawable is created and rendered.
*/
static void
p_edgeDetection(GapEdgeContext *ectx)
{
GimpPixelRgn refPR;
GimpPixelRgn edgePR;
gpointer pr;
p_createEmptyEdgeDrawable(ectx);
if(ectx->edgeDrawable == NULL)
{
return;
}
gimp_pixel_rgn_init (&refPR, ectx->refDrawable, 0, 0
, ectx->refDrawable->width, ectx->refDrawable->height
, FALSE /* dirty */
, FALSE /* shadow */
);
gimp_pixel_rgn_init (&edgePR, ectx->edgeDrawable, 0, 0
, ectx->edgeDrawable->width, ectx->edgeDrawable->height
, TRUE /* dirty */
, FALSE /* shadow */
);
/* compare pixel areas in tiled portions via pixel region processing loops.
*/
for (pr = gimp_pixel_rgns_register (2, &refPR, &edgePR);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
p_edgeProcessingForOneRegion (&refPR, &edgePR, ectx);
}
gimp_drawable_flush (ectx->edgeDrawable);
}
static void
mblur_radial (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;
guchar *d;
guchar pixel[4];
guchar p1[4], p2[4], p3[4], p4[4];
gint32 sum[4];
gint progress, max_progress, c;
gint x, y, i, p, n, count;
gdouble angle, theta, r, xx, yy, xr, yr;
gdouble phi, phi_start, s_val, c_val;
gdouble dx, dy;
/* initialize */
xx = 0.0;
yy = 0.0;
center_x = mbvals.center_x;
center_y = mbvals.center_y;
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;
angle = gimp_deg_to_rad (mbvals.angle);
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++)
{
xr = (gdouble) x - center_x;
yr = (gdouble) y - center_y;
r = sqrt (SQR (xr) + SQR (yr));
n = r * angle;
if (angle == 0.0)
{
gimp_pixel_fetcher_get_pixel (pft, x, y, d);
d += dest_rgn.bpp;
continue;
}
/* ensure quality with small angles */
if (n < 3)
n = 3; /* always use at least 3 (interpolation) steps */
/* limit loop count due to performanc reasons */
if (n > 100)
n = 100 + sqrt (n-100);
if (xr != 0.0)
{
phi = atan(yr/xr);
if (xr < 0.0)
phi = G_PI + phi;
}
else
{
if (yr >= 0.0)
phi = G_PI_2;
else
phi = -G_PI_2;
}
for (c = 0; c < img_bpp; c++)
sum[c] = 0;
if (n == 1)
phi_start = phi;
else
phi_start = phi + angle/2.0;
theta = angle / (gdouble)n;
count = 0;
for (i = 0; i < n; i++)
{
s_val = sin (phi_start - (gdouble) i * theta);
c_val = cos (phi_start - (gdouble) i * theta);
xx = center_x + r * c_val;
yy = center_y + r * s_val;
if ((yy < y1) || (yy >= y1 + height) ||
(xx < x1) || (xx >= x1 + width))
continue;
++count;
if ((xx + 1 < x1 + width) && (yy + 1 < y1 + height))
{
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];
}
}
if (count == 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/count) != 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] / count;
}
}
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);
}
static void
mblur_linear (GimpDrawable *drawable,
GimpPreview *preview,
gint x1,
gint y1,
gint width,
gint height)
{
GimpPixelRgn dest_rgn;
GimpPixelFetcher *pft;
gpointer pr;
GimpRGB background;
guchar *dest;
guchar *d;
guchar pixel[4];
gint32 sum[4];
gint progress, max_progress;
gint c, p;
gint x, y, i, xx, yy, n;
gint dx, dy, px, py, swapdir, err, e, s1, s2;
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;
px = (gdouble) n * cos (mbvals.angle / 180.0 * G_PI);
py = (gdouble) n * sin (mbvals.angle / 180.0 * G_PI);
/*
* Initialization for Bresenham algorithm:
* dx = abs(x2-x1), s1 = sign(x2-x1)
* dy = abs(y2-y1), s2 = sign(y2-y1)
*/
if ((dx = px) != 0)
{
if (dx < 0)
{
dx = -dx;
s1 = -1;
}
else
s1 = 1;
}
else
s1 = 0;
if ((dy = py) != 0)
{
if (dy < 0)
{
dy = -dy;
s2 = -1;
}
else
s2 = 1;
}
else
s2 = 0;
if (dy > dx)
{
swapdir = dx;
dx = dy;
dy = swapdir;
swapdir = 1;
}
else
swapdir = 0;
dy *= 2;
err = dy - dx; /* Initial error term */
dx *= 2;
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++)
{
xx = x; yy = y; e = err;
for (c = 0; c < img_bpp; c++)
sum[c]= 0;
for (i = 0; i < n; )
{
gimp_pixel_fetcher_get_pixel (pft, xx, yy, 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];
}
i++;
while (e >= 0 && dx)
{
if (swapdir)
xx += s1;
else
yy += s2;
e -= dx;
}
if (swapdir)
yy += s2;
else
xx += s1;
e += dy;
if ((xx < x1) || (xx >= x1 + width) ||
(yy < y1) || (yy >= y1 + height))
break;
}
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);
}
/**
* Get a read-write tile iterator for a portion of a drawable.
* Returns -1 if it cannot create the iterator.
*/
int
rectangle_new_tile_stream (int image, int drawable,
int left, int top,
int width, int height)
{
// Get an id to use for the iterator
int id = next_iterator_id ();
if (id < 0)
{
return id;
}
// Allocate space for information on the iterator
TileStream *stream = (TileStream *) g_malloc0 (sizeof (TileStream));
if (stream == NULL)
{
return -1;
}
// Fill in the basic data
stream->image = image;
stream->drawable = drawable;
stream->left = left;
stream->top = top;
stream->width = width;
stream->height = height;
stream->source = gimp_drawable_get (drawable);
if (stream->source == NULL)
{
g_free (stream);
return -1;
} // if we could not get the drawable
stream->target = gimp_drawable_get (drawable);
if (stream->target == NULL)
{
g_free (stream->source);
g_free (stream);
return -1;
}
// Fill in the more advanced data
gimp_pixel_rgn_init (&(stream->source_region),
stream->source,
left, top, width, height,
FALSE, FALSE);
gimp_pixel_rgn_init (&(stream->target_region),
stream->target,
left, top, width, height,
TRUE, TRUE);
stream->iterator = gimp_pixel_rgns_register (2, &(stream->source_region),
&(stream->target_region));
// Copy pixels over in case the user doesn't change them
copy_pixels (&(stream->target_region), stream->source_region.data);
// HACK FOR TESTING
invert_pixels (&(stream->target_region));
// And we're done
streams[id] = stream;
return id;
} // rectangle_new_tile_stream
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
gint sel_x1, sel_y1, sel_x2, sel_y2;
gint img_height, img_width, img_bpp, img_has_alpha;
GimpDrawable *drawable;
GimpRunMode run_mode;
GimpPDBStatusType status;
*nreturn_vals = 1;
*return_vals = values;
status = GIMP_PDB_SUCCESS;
if (param[0].type != GIMP_PDB_INT32)
status = GIMP_PDB_CALLING_ERROR;
run_mode = param[0].data.d_int32;
INIT_I18N ();
if (param[2].type != GIMP_PDB_DRAWABLE)
status = GIMP_PDB_CALLING_ERROR;
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);
img_has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
if (!gimp_drawable_is_rgb (drawable->drawable_id))
status = GIMP_PDB_CALLING_ERROR;
if (status == GIMP_PDB_SUCCESS)
{
gr = g_rand_new ();
memset (&qbist_info, 0, sizeof (qbist_info));
create_info (&qbist_info.info);
qbist_info.oversampling = 4;
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &qbist_info);
/* Get information from the dialog */
if (dialog_run ())
{
status = GIMP_PDB_SUCCESS;
gimp_set_data (PLUG_IN_PROC, &qbist_info, sizeof (QbistInfo));
}
else
status = GIMP_PDB_EXECUTION_ERROR;
break;
case GIMP_RUN_NONINTERACTIVE:
status = GIMP_PDB_CALLING_ERROR;
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &qbist_info);
status = GIMP_PDB_SUCCESS;
break;
default:
status = GIMP_PDB_CALLING_ERROR;
break;
}
if (status == GIMP_PDB_SUCCESS)
{
GimpPixelRgn imagePR;
gpointer pr;
gimp_tile_cache_ntiles ((drawable->width + gimp_tile_width () - 1) /
gimp_tile_width ());
gimp_pixel_rgn_init (&imagePR, drawable,
0, 0, img_width, img_height, TRUE, TRUE);
optimize (&qbist_info.info);
gimp_progress_init (_("Qbist"));
for (pr = gimp_pixel_rgns_register (1, &imagePR);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
gint row;
for (row = 0; row < imagePR.h; row++)
{
qbist (&qbist_info.info,
imagePR.data + row * imagePR.rowstride,
imagePR.x,
imagePR.y + row,
imagePR.w,
sel_x2 - sel_x1,
sel_y2 - sel_y1,
imagePR.bpp,
qbist_info.oversampling);
}
gimp_progress_update ((gfloat) (imagePR.y - sel_y1) /
(gfloat) (sel_y2 - sel_y1));
}
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
sel_x1, sel_y1,
(sel_x2 - sel_x1), (sel_y2 - sel_y1));
gimp_displays_flush ();
}
g_rand_free (gr);
}
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
gimp_drawable_detach (drawable);
}
static gint32
tile (gint32 image_id,
gint32 drawable_id,
gint32 *layer_id)
{
GimpPixelRgn src_rgn;
GimpPixelRgn dest_rgn;
GimpDrawable *drawable;
GimpDrawable *new_layer;
GimpImageBaseType image_type = GIMP_RGB;
gint32 new_image_id = 0;
gint old_width;
gint old_height;
gint i, j;
gint progress;
gint max_progress;
gpointer pr;
/* sanity check parameters */
if (tvals.new_width < 1 || tvals.new_height < 1)
{
*layer_id = -1;
return -1;
}
/* initialize */
old_width = gimp_drawable_width (drawable_id);
old_height = gimp_drawable_height (drawable_id);
if (tvals.new_image)
{
/* create a new image */
switch (gimp_drawable_type (drawable_id))
{
case GIMP_RGB_IMAGE:
case GIMP_RGBA_IMAGE:
image_type = GIMP_RGB;
break;
case GIMP_GRAY_IMAGE:
case GIMP_GRAYA_IMAGE:
image_type = GIMP_GRAY;
break;
case GIMP_INDEXED_IMAGE:
case GIMP_INDEXEDA_IMAGE:
image_type = GIMP_INDEXED;
break;
}
new_image_id = gimp_image_new (tvals.new_width, tvals.new_height,
image_type);
gimp_image_undo_disable (new_image_id);
*layer_id = gimp_layer_new (new_image_id, _("Background"),
tvals.new_width, tvals.new_height,
gimp_drawable_type (drawable_id),
100, GIMP_NORMAL_MODE);
if (*layer_id == -1)
return -1;
gimp_image_insert_layer (new_image_id, *layer_id, -1, 0);
new_layer = gimp_drawable_get (*layer_id);
/* Get the source drawable */
drawable = gimp_drawable_get (drawable_id);
}
else
{
gimp_image_undo_group_start (image_id);
gimp_image_resize (image_id,
tvals.new_width, tvals.new_height,
0, 0);
if (gimp_item_is_layer (drawable_id))
gimp_layer_resize (drawable_id,
tvals.new_width, tvals.new_height,
0, 0);
/* Get the source drawable */
drawable = gimp_drawable_get (drawable_id);
new_layer = drawable;
}
/* progress */
progress = 0;
max_progress = tvals.new_width * tvals.new_height;
/* tile... */
for (i = 0; i < tvals.new_height; i += old_height)
{
gint height = old_height;
if (height + i > tvals.new_height)
height = tvals.new_height - i;
for (j = 0; j < tvals.new_width; j += old_width)
{
gint width = old_width;
gint c;
if (width + j > tvals.new_width)
width = tvals.new_width - j;
gimp_pixel_rgn_init (&src_rgn, drawable,
0, 0, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&dest_rgn, new_layer,
j, i, width, height, TRUE, FALSE);
for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn), c = 0;
pr != NULL;
pr = gimp_pixel_rgns_process (pr), c++)
{
gint k;
for (k = 0; k < src_rgn.h; k++)
memcpy (dest_rgn.data + k * dest_rgn.rowstride,
src_rgn.data + k * src_rgn.rowstride,
src_rgn.w * src_rgn.bpp);
progress += src_rgn.w * src_rgn.h;
if (c % 16 == 0)
gimp_progress_update ((gdouble) progress /
(gdouble) max_progress);
}
}
}
gimp_drawable_update (new_layer->drawable_id,
0, 0, new_layer->width, new_layer->height);
gimp_drawable_detach (drawable);
if (tvals.new_image)
{
gimp_drawable_detach (new_layer);
/* copy the colormap, if necessary */
if (image_type == GIMP_INDEXED)
{
guchar *cmap;
gint ncols;
cmap = gimp_image_get_colormap (image_id, &ncols);
gimp_image_set_colormap (new_image_id, cmap, ncols);
g_free (cmap);
}
gimp_image_undo_enable (new_image_id);
}
else
{
gimp_image_undo_group_end (image_id);
}
return new_image_id;
}
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;
}
}
}
/*
* 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
edge (GimpDrawable *drawable)
{
GimpPixelRgn src_rgn, dest_rgn;
gpointer pr;
GimpPixelFetcher *pft;
guchar *srcrow, *src;
guchar *destrow, *dest;
guchar pix00[4], pix01[4], pix02[4];
guchar pix10[4], pix11[4], pix12[4];
guchar pix20[4], pix21[4], pix22[4];
glong width, height;
gint alpha;
gboolean has_alpha;
gint chan;
gint x, y;
gint x1, y1, x2, y2;
gint maxval;
gint cur_progress;
gint max_progress;
gdouble per_progress;
if (evals.amount < 1.0)
evals.amount = 1.0;
pft = gimp_pixel_fetcher_new (drawable, FALSE);
gimp_pixel_fetcher_set_edge_mode (pft, evals.wrapmode);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = gimp_drawable_width (drawable->drawable_id);
height = gimp_drawable_height (drawable->drawable_id);
alpha = gimp_drawable_bpp (drawable->drawable_id);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
if (has_alpha)
alpha--;
maxval = 255;
cur_progress = 0;
per_progress = 0.0;
max_progress = (x2 - x1) * (y2 - y1) / 100;
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);
for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
srcrow = src_rgn.data;
destrow = dest_rgn.data;
for (y = dest_rgn.y;
y < (dest_rgn.y + dest_rgn.h);
y++, srcrow += src_rgn.rowstride, destrow += dest_rgn.rowstride)
{
src = srcrow;
dest = destrow;
for (x = dest_rgn.x;
x < (dest_rgn.x + dest_rgn.w);
x++, src += src_rgn.bpp, dest += dest_rgn.bpp)
{
if (dest_rgn.x < x && x < dest_rgn.x + dest_rgn.w - 2 &&
dest_rgn.y < y && y < dest_rgn.y + dest_rgn.h - 2)
{
/*
* 3x3 kernel is inside of the tile -- do fast
* version
*/
for (chan = 0; chan < alpha; chan++)
{
/* get the 3x3 kernel into a guchar array,
* and send it to edge_detect */
guchar kernel[9];
gint i,j;
#define PIX(X,Y) src[ (Y-1)*(int)src_rgn.rowstride + (X-1)*(int)src_rgn.bpp + chan ]
/* make convolution */
for(i = 0; i < 3; i++)
for(j = 0; j < 3; j++)
kernel[3*i + j] = PIX(i,j);
#undef PIX
dest[chan] = edge_detect (kernel);
}
}
else
{
/*
* The kernel is not inside of the tile -- do slow
* version
*/
gimp_pixel_fetcher_get_pixel (pft, x-1, y-1, pix00);
gimp_pixel_fetcher_get_pixel (pft, x , y-1, pix10);
gimp_pixel_fetcher_get_pixel (pft, x+1, y-1, pix20);
gimp_pixel_fetcher_get_pixel (pft, x-1, y , pix01);
gimp_pixel_fetcher_get_pixel (pft, x , y , pix11);
gimp_pixel_fetcher_get_pixel (pft, x+1, y , pix21);
gimp_pixel_fetcher_get_pixel (pft, x-1, y+1, pix02);
gimp_pixel_fetcher_get_pixel (pft, x , y+1, pix12);
gimp_pixel_fetcher_get_pixel (pft, x+1, y+1, pix22);
for (chan = 0; chan < alpha; chan++)
{
guchar kernel[9];
kernel[0] = pix00[chan];
kernel[1] = pix01[chan];
kernel[2] = pix02[chan];
kernel[3] = pix10[chan];
kernel[4] = pix11[chan];
kernel[5] = pix12[chan];
kernel[6] = pix20[chan];
kernel[7] = pix21[chan];
kernel[8] = pix22[chan];
dest[chan] = edge_detect (kernel);
}
}
if (has_alpha)
dest[alpha] = src[alpha];
}
}
cur_progress += dest_rgn.w * dest_rgn.h;
if (cur_progress > max_progress)
{
cur_progress = cur_progress - max_progress;
per_progress = per_progress + 0.01;
gimp_progress_update (per_progress);
}
}
gimp_progress_update (1.0);
gimp_pixel_fetcher_destroy (pft);
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
clear_curled_region (gint32 drawable_id)
{
GimpPixelRgn src_rgn, dest_rgn;
gpointer pr;
gint x = 0;
gint y = 0;
guint x1, y1, i;
guchar *dest, *src, *pp, *sp;
guint alpha_pos, progress, max_progress;
GimpDrawable *drawable;
max_progress = 2 * sel_width * sel_height;
progress = max_progress / 2;
drawable = gimp_drawable_get (drawable_id);
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
gimp_pixel_rgn_init (&src_rgn, drawable,
sel_x, sel_y, true_sel_width, true_sel_height,
FALSE, FALSE);
gimp_pixel_rgn_init (&dest_rgn, drawable,
sel_x, sel_y, true_sel_width, true_sel_height,
TRUE, TRUE);
alpha_pos = dest_rgn.bpp - 1;
for (pr = gimp_pixel_rgns_register (2, &dest_rgn, &src_rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
dest = dest_rgn.data;
src = src_rgn.data;
for (y1 = dest_rgn.y; y1 < dest_rgn.y + dest_rgn.h; y1++)
{
sp = src;
pp = dest;
for (x1 = dest_rgn.x; x1 < dest_rgn.x + dest_rgn.w; x1++)
{
/* Map coordinates to get the curl correct... */
switch (curl.orientation)
{
case CURL_ORIENTATION_VERTICAL:
x = (CURL_EDGE_RIGHT (curl.edge) ?
x1 - sel_x : sel_width - 1 - (x1 - sel_x));
y = (CURL_EDGE_UPPER (curl.edge) ?
y1 - sel_y : sel_height - 1 - (y1 - sel_y));
break;
case CURL_ORIENTATION_HORIZONTAL:
x = (CURL_EDGE_LOWER (curl.edge) ?
y1 - sel_y : sel_width - 1 - (y1 - sel_y));
y = (CURL_EDGE_LEFT (curl.edge) ?
x1 - sel_x : sel_height - 1 - (x1 - sel_x));
break;
}
for (i = 0; i < alpha_pos; i++)
pp[i] = sp[i];
if (right_of_diagr (x, y) ||
(right_of_diagm (x, y) &&
below_diagb (x, y) &&
!inside_circle (x, y)))
{
/* Right of the curl */
pp[alpha_pos] = 0;
}
else
{
pp[alpha_pos] = sp[alpha_pos];
}
pp += dest_rgn.bpp;
sp += src_rgn.bpp;
}
src += src_rgn.rowstride;
dest += dest_rgn.rowstride;
}
progress += dest_rgn.w * dest_rgn.h;
gimp_progress_update ((double) progress / (double) max_progress);
}
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable_id, TRUE);
gimp_drawable_update (drawable_id,
sel_x, sel_y,
true_sel_width, true_sel_height);
gimp_drawable_detach (drawable);
}
static gint32
do_curl_effect (gint32 drawable_id)
{
gint x = 0;
gint y = 0;
gboolean color_image;
gint x1, y1, k;
guint alpha_pos, progress, max_progress;
gdouble intensity, alpha;
GimpVector2 v, dl, dr;
gdouble dl_mag, dr_mag, angle, factor;
guchar *pp, *dest, fore_grayval, back_grayval;
guchar *gradsamp;
GimpPixelRgn dest_rgn;
gpointer pr;
gint32 curl_layer_id;
guchar *grad_samples = NULL;
color_image = gimp_drawable_is_rgb (drawable_id);
curl_layer =
gimp_drawable_get (gimp_layer_new (image_id,
_("Curl Layer"),
true_sel_width,
true_sel_height,
color_image ?
GIMP_RGBA_IMAGE : GIMP_GRAYA_IMAGE,
100, GIMP_NORMAL_MODE));
curl_layer_id = curl_layer->drawable_id;
gimp_image_insert_layer (image_id, curl_layer->drawable_id,
gimp_item_get_parent (drawable_id),
drawable_position);
gimp_drawable_fill (curl_layer->drawable_id, GIMP_FILL_TRANSPARENT);
gimp_drawable_offsets (drawable_id, &x1, &y1);
gimp_layer_set_offsets (curl_layer->drawable_id, sel_x + x1, sel_y + y1);
gimp_tile_cache_ntiles (2 * (curl_layer->width / gimp_tile_width () + 1));
gimp_pixel_rgn_init (&dest_rgn, curl_layer,
0, 0, true_sel_width, true_sel_height, TRUE, TRUE);
/* Init shade_under */
gimp_vector2_set (&dl, -sel_width, -sel_height);
dl_mag = gimp_vector2_length (&dl);
gimp_vector2_set (&dr,
-(sel_width - right_tangent.x),
-(sel_height - right_tangent.y));
dr_mag = gimp_vector2_length (&dr);
alpha = acos (gimp_vector2_inner_product (&dl, &dr) / (dl_mag * dr_mag));
/* Init shade_curl */
fore_grayval = GIMP_RGB_LUMINANCE (fore_color[0],
fore_color[1],
fore_color[2]) + 0.5;
back_grayval = GIMP_RGB_LUMINANCE (back_color[0],
back_color[1],
back_color[2]) + 0.5;
/* Gradient Samples */
switch (curl.colors)
{
case CURL_COLORS_FG_BG:
break;
case CURL_COLORS_GRADIENT:
grad_samples = get_gradient_samples (curl_layer->drawable_id, FALSE);
break;
case CURL_COLORS_GRADIENT_REVERSE:
grad_samples = get_gradient_samples (curl_layer->drawable_id, TRUE);
break;
}
max_progress = 2 * sel_width * sel_height;
progress = 0;
alpha_pos = dest_rgn.bpp - 1;
/* Main loop */
for (pr = gimp_pixel_rgns_register (1, &dest_rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
dest = dest_rgn.data;
for (y1 = dest_rgn.y; y1 < dest_rgn.y + dest_rgn.h; y1++)
{
pp = dest;
for (x1 = dest_rgn.x; x1 < dest_rgn.x + dest_rgn.w; x1++)
{
/* Map coordinates to get the curl correct... */
switch (curl.orientation)
{
case CURL_ORIENTATION_VERTICAL:
x = CURL_EDGE_RIGHT (curl.edge) ? x1 : sel_width - 1 - x1;
y = CURL_EDGE_UPPER (curl.edge) ? y1 : sel_height - 1 - y1;
break;
case CURL_ORIENTATION_HORIZONTAL:
x = CURL_EDGE_LOWER (curl.edge) ? y1 : sel_width - 1 - y1;
y = CURL_EDGE_LEFT (curl.edge) ? x1 : sel_height - 1 - x1;
break;
}
if (left_of_diagl (x, y))
{ /* uncurled region */
for (k = 0; k <= alpha_pos; k++)
pp[k] = 0;
}
else if (right_of_diagr (x, y) ||
(right_of_diagm (x, y) &&
below_diagb (x, y) &&
!inside_circle (x, y)))
{
/* curled region */
for (k = 0; k <= alpha_pos; k++)
pp[k] = 0;
}
else
{
v.x = -(sel_width - x);
v.y = -(sel_height - y);
angle = acos (gimp_vector2_inner_product (&v, &dl) /
(gimp_vector2_length (&v) * dl_mag));
if (inside_circle (x, y) || below_diagb (x, y))
{
/* Below the curl. */
factor = angle / alpha;
for (k = 0; k < alpha_pos; k++)
pp[k] = 0;
pp[alpha_pos] = (curl.shade ?
(guchar) ((float) 255 * (float) factor) :
0);
}
else
{
/* On the curl */
switch (curl.colors)
{
case CURL_COLORS_FG_BG:
intensity = pow (sin (G_PI * angle / alpha), 1.5);
if (color_image)
{
pp[0] = (intensity * back_color[0] +
(1.0 - intensity) * fore_color[0]);
pp[1] = (intensity * back_color[1] +
(1.0 - intensity) * fore_color[1]);
pp[2] = (intensity * back_color[2] +
(1.0 - intensity) * fore_color[2]);
}
else
pp[0] = (intensity * back_grayval +
(1 - intensity) * fore_grayval);
pp[alpha_pos] = (guchar) ((double) 255.99 *
(1.0 - intensity *
(1.0 - curl.opacity)));
break;
case CURL_COLORS_GRADIENT:
case CURL_COLORS_GRADIENT_REVERSE:
/* Calculate position in Gradient */
intensity =
(angle/alpha) + sin (G_PI*2 * angle/alpha) * 0.075;
/* Check boundaries */
intensity = CLAMP (intensity, 0.0, 1.0);
gradsamp = (grad_samples +
((guint) (intensity * NGRADSAMPLES)) *
dest_rgn.bpp);
if (color_image)
{
pp[0] = gradsamp[0];
pp[1] = gradsamp[1];
pp[2] = gradsamp[2];
}
else
pp[0] = gradsamp[0];
pp[alpha_pos] =
(guchar) ((double) gradsamp[alpha_pos] *
(1.0 - intensity * (1.0 - curl.opacity)));
break;
}
}
}
pp += dest_rgn.bpp;
}
dest += dest_rgn.rowstride;
}
progress += dest_rgn.w * dest_rgn.h;
gimp_progress_update ((double) progress / (double) max_progress);
}
gimp_progress_update (1.0);
gimp_drawable_flush (curl_layer);
gimp_drawable_merge_shadow (curl_layer->drawable_id, FALSE);
gimp_drawable_update (curl_layer->drawable_id,
0, 0, curl_layer->width, curl_layer->height);
gimp_drawable_detach (curl_layer);
g_free (grad_samples);
return curl_layer_id;
}
static void
softglow (GimpDrawable *drawable,
GimpPreview *preview)
{
GimpPixelRgn src_rgn, dest_rgn;
GimpPixelRgn *pr;
gint width, height;
gint bytes;
gboolean has_alpha;
guchar *dest;
guchar *src, *sp_p, *sp_m;
gdouble n_p[5], n_m[5];
gdouble d_p[5], d_m[5];
gdouble bd_p[5], bd_m[5];
gdouble *val_p, *val_m, *vp, *vm;
gint x1, y1, x2, y2;
gint i, j;
gint row, col, b;
gint terms;
gint progress, max_progress;
gint initial_p[4];
gint initial_m[4];
gint tmp;
gdouble radius;
gdouble std_dev;
gdouble val;
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;
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
val_p = g_new (gdouble, MAX (width, height));
val_m = g_new (gdouble, MAX (width, height));
dest = g_new0 (guchar, width * height);
progress = 0;
max_progress = width * height * 3;
/* Initialize the pixel regions. */
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 = dest + (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 sigmoidal transfer */
val = dest_ptr[col] / 255.0;
val = 255.0 / (1 + exp (-(SIGMOIDAL_BASE + (svals.sharpness * SIGMOIDAL_RANGE)) * (val - 0.5)));
val = val * svals.brightness;
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 = fabs (svals.glow_radius) + 1.0;
std_dev = sqrt (-(radius * radius) / (2 * log (1.0 / 255.0)));
/* derive the constants for calculating the gaussian from the std dev */
find_constants (n_p, n_m, d_p, d_m, bd_p, bd_m, std_dev);
/* First the vertical pass */
for (col = 0; col < width; col++)
{
memset (val_p, 0, height * sizeof (gdouble));
memset (val_m, 0, height * sizeof (gdouble));
src = dest + col;
sp_p = src;
sp_m = src + width * (height - 1);
vp = val_p;
vm = val_m + (height - 1);
/* Set up the first vals */
initial_p[0] = sp_p[0];
initial_m[0] = sp_m[0];
for (row = 0; row < height; row++)
{
gdouble *vpptr, *vmptr;
terms = (row < 4) ? row : 4;
vpptr = vp; vmptr = vm;
for (i = 0; i <= terms; i++)
{
*vpptr += n_p[i] * sp_p[-i * width] - d_p[i] * vp[-i];
*vmptr += n_m[i] * sp_m[i * width] - d_m[i] * vm[i];
}
for (j = i; j <= 4; j++)
{
*vpptr += (n_p[j] - bd_p[j]) * initial_p[0];
*vmptr += (n_m[j] - bd_m[j]) * initial_m[0];
}
sp_p += width;
sp_m -= width;
vp ++;
vm --;
}
transfer_pixels (val_p, val_m, dest + 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_p, 0, width * sizeof (gdouble));
memset (val_m, 0, width * sizeof (gdouble));
src = dest + row * width;
sp_p = src;
sp_m = src + width - 1;
vp = val_p;
vm = val_m + width - 1;
/* Set up the first vals */
initial_p[0] = sp_p[0];
initial_m[0] = sp_m[0];
for (col = 0; col < width; col++)
{
gdouble *vpptr, *vmptr;
terms = (col < 4) ? col : 4;
vpptr = vp; vmptr = vm;
for (i = 0; i <= terms; i++)
{
*vpptr += n_p[i] * sp_p[-i] - d_p[i] * vp[-i];
*vmptr += n_m[i] * sp_m[i] - d_m[i] * vm[i];
}
for (j = i; j <= 4; j++)
{
*vpptr += (n_p[j] - bd_p[j]) * initial_p[0];
*vmptr += (n_m[j] - bd_m[j]) * initial_m[0];
}
sp_p ++;
sp_m --;
vp ++;
vm --;
}
transfer_pixels (val_p, val_m, dest + row * width, 1, width);
if (!preview)
{
progress += width;
if ((row % 5) == 0)
gimp_progress_update ((gdouble) progress / (gdouble) max_progress);
}
}
/* 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);
for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
guchar *src_ptr = src_rgn.data;
guchar *dest_ptr = dest_rgn.data;
guchar *blur_ptr = dest + (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++)
{
/* screen op */
for (b = 0; b < (has_alpha ? (bytes - 1) : bytes); b++)
dest_ptr[col * bytes + b] =
255 - INT_MULT((255 - src_ptr[col * bytes + b]),
(255 - blur_ptr[col]), tmp);
if (has_alpha)
dest_ptr[col * bytes + b] = src_ptr[col * bytes + b];
}
src_ptr += src_rgn.rowstride;
dest_ptr += dest_rgn.rowstride;
blur_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);
}
}
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, (x2 - x1), (y2 - y1));
}
/* free up buffers */
g_free (val_p);
g_free (val_m);
g_free (dest);
}
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);
}
static void
nova (GimpDrawable *drawable,
GimpPreview *preview)
{
GimpPixelRgn src_rgn;
GimpPixelRgn dest_rgn;
gpointer pr;
guchar *src_row, *dest_row, *save_src;
guchar *src, *dest;
gint x1, y1, x2, y2, x, y;
gint row, col;
gint alpha, bpp;
gint progress, max_progress;
gboolean has_alpha;
gint xc, yc; /* center of nova */
gdouble u, v, l, w, w1, c, t;
gdouble *spoke;
gdouble nova_alpha, src_alpha, new_alpha = 0.0;
gdouble compl_ratio, ratio;
GimpRGB color;
GimpRGB *spokecolor;
GimpHSV hsv;
gdouble spokecol;
gint i;
GRand *gr;
guchar *cache = NULL;
gint width, height;
gdouble zoom = 0.0;
gr = g_rand_new ();
/* initialize */
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
spoke = g_new (gdouble, pvals.nspoke);
spokecolor = g_new (GimpRGB, pvals.nspoke);
gimp_rgb_set_alpha (&pvals.color, 1.0);
gimp_rgb_to_hsv (&pvals.color, &hsv);
for (i = 0; i < pvals.nspoke; i++)
{
spoke[i] = gauss (gr);
hsv.h += ((gdouble) pvals.randomhue / 360.0) *
g_rand_double_range (gr, -0.5, 0.5);
if (hsv.h < 0)
hsv.h += 1.0;
else if (hsv.h >= 1.0)
hsv.h -= 1.0;
gimp_hsv_to_rgb (&hsv, spokecolor + i);
}
if (preview)
{
cache = gimp_zoom_preview_get_source (GIMP_ZOOM_PREVIEW (preview),
&width, &height, &bpp);
zoom = gimp_zoom_preview_get_factor (GIMP_ZOOM_PREVIEW (preview));
gimp_preview_transform (preview,
pvals.xcenter, pvals.ycenter, &xc, &yc);
x1 = 0;
y1 = 0;
x2 = width;
y2 = height;
}
else
{
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
bpp = gimp_drawable_bpp (drawable->drawable_id);
xc = pvals.xcenter;
yc = pvals.ycenter;
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);
}
alpha = (has_alpha) ? bpp - 1 : bpp;
/* Initialize progress */
progress = 0;
max_progress = (x2 - x1) * (y2 - y1);
if (preview)
{
save_src = src_row = g_new (guchar, y2 * width * bpp);
memcpy (src_row, cache, y2 * width * bpp);
dest_row = g_new (guchar, y2 * width * bpp);
dest = dest_row;
src = src_row;
for (row = 0, y = 0; row < y2; row++, y++)
{
for (col = 0, x = 0; col < x2; col++, x++)
{
u = ((gdouble) (x - xc) /
((gdouble) pvals.radius * width /
drawable->width * zoom));
v = ((gdouble) (y - yc) /
((gdouble) pvals.radius * height /
drawable->height * zoom));
l = sqrt (SQR (u) + SQR (v));
/* This algorithm is still under construction. */
t = (atan2 (u, v) / (2 * G_PI) + .51) * pvals.nspoke;
i = (gint) floor (t);
t -= i;
i %= pvals.nspoke;
w1 = spoke[i] * (1 - t) + spoke[(i + 1) % pvals.nspoke] * t;
w1 = w1 * w1;
w = 1.0 / (l + 0.001) * 0.9;
nova_alpha = CLAMP (w, 0.0, 1.0);
if (has_alpha)
{
src_alpha = (gdouble) src[alpha] / 255.0;
new_alpha = src_alpha + (1.0 - src_alpha) * nova_alpha;
if (new_alpha != 0.0)
ratio = nova_alpha / new_alpha;
else
ratio = 0.0;
}
else
ratio = nova_alpha;
compl_ratio = 1.0 - ratio;
/* red or gray */
spokecol = (gdouble)spokecolor[i ].r * (1.0-t) +
(gdouble)spokecolor[(i+1) % pvals.nspoke].r * t;
if (w>1.0)
color.r = CLAMP (spokecol * w, 0.0, 1.0);
else
color.r = src[0]/255.0 * compl_ratio + spokecol * ratio;
c = CLAMP (w1 * w, 0.0, 1.0);
color.r += c;
dest[0] = CLAMP (color.r*255.0, 0, 255);
if (bpp>2)
{
/* green */
spokecol = (gdouble)spokecolor[i ].g * (1.0-t) +
(gdouble)spokecolor[(i+1) % pvals.nspoke].g * t;
if (w>1.0)
color.g = CLAMP (spokecol * w, 0.0, 1.0);
else
color.g = src[1]/255.0 * compl_ratio + spokecol * ratio;
c = CLAMP (w1 * w, 0.0, 1.0);
color.g += c;
dest[1] = CLAMP (color.g*255.0, 0, 255);
/* blue */
spokecol = (gdouble)spokecolor[i ].b * (1.0-t) +
(gdouble)spokecolor[(i+1) % pvals.nspoke].b * t;
if (w>1.0)
color.b = CLAMP (spokecol * w, 0.0, 1.0);
else
color.b = src[2]/255.0 * compl_ratio + spokecol * ratio;
c = CLAMP (w1 * w, 0.0, 1.0);
color.b += c;
dest[2] = CLAMP (color.b*255.0, 0, 255);
}
/* alpha */
if (has_alpha)
dest[alpha] = new_alpha * 255.0;
src += bpp;
dest += bpp;
}
}
gimp_preview_draw_buffer (preview, dest_row, bpp * width);
g_free (cache);
g_free (save_src);
g_free (dest_row);
}
else
{ /* normal mode */
for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
pr != NULL ;
pr = gimp_pixel_rgns_process (pr))
{
src_row = src_rgn.data;
dest_row = dest_rgn.data;
for (row = 0, y = src_rgn.y; row < src_rgn.h; row++, y++)
{
src = src_row;
dest = dest_row;
for (col = 0, x = src_rgn.x; col < src_rgn.w; col++, x++)
{
u = (gdouble) (x-xc) / pvals.radius;
v = (gdouble) (y-yc) / pvals.radius;
l = sqrt(u*u + v*v);
/* This algorithm is still under construction. */
t = (atan2 (u, v) / (2 * G_PI) + .51) * pvals.nspoke;
i = (gint) floor (t);
t -= i;
i %= pvals.nspoke;
w1 = spoke[i] * (1 - t) + spoke[(i + 1) % pvals.nspoke] * t;
w1 = w1 * w1;
w = 1/(l+0.001)*0.9;
nova_alpha = CLAMP (w, 0.0, 1.0);
if (has_alpha)
{
src_alpha = (gdouble) src[alpha] / 255.0;
new_alpha = src_alpha + (1.0 - src_alpha) * nova_alpha;
if (new_alpha != 0.0)
ratio = nova_alpha / new_alpha;
else
ratio = 0.0;
}
else
ratio = nova_alpha;
compl_ratio = 1.0 - ratio;
switch (bpp)
{
case 1:
case 2:
/* gray */
spokecol = (gdouble)spokecolor[i ].r * (1.0-t) +
(gdouble)spokecolor[(i+1) % pvals.nspoke].r * t;
if (w>1.0)
color.r = CLAMP (spokecol * w, 0.0, 1.0);
else
color.r = src[0]/255.0 * compl_ratio + spokecol * ratio;
c = CLAMP (w1 * w, 0.0, 1.0);
color.r += c;
dest[0] = CLAMP (color.r*255.0, 0, 255);
break;
case 3:
case 4:
/* red */
spokecol = (gdouble)spokecolor[i ].r * (1.0-t) +
(gdouble)spokecolor[(i+1) % pvals.nspoke].r * t;
if (w>1.0)
color.r = CLAMP (spokecol * w, 0.0, 1.0);
else
color.r = src[0]/255.0 * compl_ratio + spokecol * ratio;
c = CLAMP (w1 * w, 0.0, 1.0);
color.r += c;
dest[0] = CLAMP (color.r*255.0, 0, 255);
/* green */
spokecol = (gdouble)spokecolor[i ].g * (1.0-t) +
(gdouble)spokecolor[(i+1) % pvals.nspoke].g * t;
if (w>1.0)
color.g = CLAMP (spokecol * w, 0.0, 1.0);
else
color.g = src[1]/255.0 * compl_ratio + spokecol * ratio;
c = CLAMP (w1 * w, 0.0, 1.0);
color.g += c;
dest[1] = CLAMP (color.g*255.0, 0, 255);
/* blue */
spokecol = (gdouble)spokecolor[i ].b * (1.0-t) +
(gdouble)spokecolor[(i+1) % pvals.nspoke].b * t;
if (w>1.0)
color.b = CLAMP (spokecol * w, 0.0, 1.0);
else
color.b = src[2]/255.0 * compl_ratio + spokecol * ratio;
c = CLAMP (w1 * w, 0.0, 1.0);
color.b += c;
dest[2] = CLAMP (color.b*255.0, 0, 255);
break;
}
if (has_alpha)
dest[alpha] = new_alpha * 255.0;
src += src_rgn.bpp;
dest += dest_rgn.bpp;
}
src_row += src_rgn.rowstride;
dest_row += dest_rgn.rowstride;
}
/* Update progress */
progress += src_rgn.w * src_rgn.h;
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,
x1, y1, (x2 - x1), (y2 - y1));
}
g_free (spoke);
g_free (spokecolor);
g_rand_free (gr);
}
/**
* gimp_layer_new_from_pixbuf:
* @image_ID: The RGB image to which to add the layer.
* @name: The layer name.
* @pixbuf: A GdkPixbuf.
* @opacity: The layer opacity.
* @mode: The layer combination mode.
* @progress_start: start of progress
* @progress_end: end of progress
*
* Create a new layer from a %GdkPixbuf.
*
* This procedure creates a new layer from the given %GdkPixbuf. The
* image has to be an RGB image and just like with gimp_layer_new()
* you will still need to add the layer to it.
*
* If you pass @progress_end > @progress_start to this function,
* @gimp_progress_update() will be called for. You have to call
* @gimp_progress_init() beforehand.
*
* Returns: The newly created layer.
*
* Since: GIMP 2.4
*/
gint32
gimp_layer_new_from_pixbuf (gint32 image_ID,
const gchar *name,
GdkPixbuf *pixbuf,
gdouble opacity,
GimpLayerModeEffects mode,
gdouble progress_start,
gdouble progress_end)
{
GimpDrawable *drawable;
GimpPixelRgn rgn;
const guchar *pixels;
gpointer pr;
gint32 layer;
gint width;
gint height;
gint rowstride;
gint bpp;
gdouble range = progress_end - progress_start;
guint count = 0;
guint done = 0;
g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), -1);
if (gimp_image_base_type (image_ID) != GIMP_RGB)
{
g_warning ("gimp_layer_new_from_pixbuf() needs an RGB image");
return -1;
}
if (gdk_pixbuf_get_colorspace (pixbuf) != GDK_COLORSPACE_RGB)
{
g_warning ("gimp_layer_new_from_pixbuf() assumes that GdkPixbuf is RGB");
return -1;
}
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
bpp = gdk_pixbuf_get_n_channels (pixbuf);
layer = gimp_layer_new (image_ID, name, width, height,
bpp == 3 ? GIMP_RGB_IMAGE : GIMP_RGBA_IMAGE,
opacity, mode);
if (layer == -1)
return -1;
drawable = gimp_drawable_get (layer);
gimp_pixel_rgn_init (&rgn, drawable, 0, 0, width, height, TRUE, FALSE);
g_assert (bpp == rgn.bpp);
rowstride = gdk_pixbuf_get_rowstride (pixbuf);
pixels = gdk_pixbuf_get_pixels (pixbuf);
for (pr = gimp_pixel_rgns_register (1, &rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
const guchar *src = pixels + rgn.y * rowstride + rgn.x * bpp;
guchar *dest = rgn.data;
gint y;
for (y = 0; y < rgn.h; y++)
{
memcpy (dest, src, rgn.w * rgn.bpp);
src += rowstride;
dest += rgn.rowstride;
}
if (range > 0.0)
{
done += rgn.h * rgn.w;
if (count++ % 32 == 0)
gimp_progress_update (progress_start +
(gdouble) done / (width * height) * range);
}
}
if (range > 0.0)
gimp_progress_update (progress_end);
gimp_drawable_detach (drawable);
return layer;
}
static void
lcms_drawable_transform (GimpDrawable *drawable,
cmsHTRANSFORM transform,
gdouble progress_start,
gdouble progress_end)
{
GimpPixelRgn src_rgn;
GimpPixelRgn dest_rgn;
gpointer pr;
const gboolean alpha = gimp_drawable_has_alpha (drawable->drawable_id);
gdouble range = progress_end - progress_start;
guint count = 0;
guint done = 0;
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 y;
for (y = 0; y < dest_rgn.h; y++)
{
cmsDoTransform (transform, src, dest, dest_rgn.w);
/* copy the alpha values, cmsDoTransform() leaves them untouched */
if (alpha)
{
const guchar *s = src;
guchar *d = dest;
gint w = dest_rgn.w;
while (w--)
{
d[3] = s[3];
s += 4;
d += 4;
}
}
src += src_rgn.rowstride;
dest += dest_rgn.rowstride;
}
done += dest_rgn.h * dest_rgn.w;
if (count++ % 32 == 0)
gimp_progress_update (progress_start +
(gdouble) done /
(drawable->width * drawable->height) * range);
}
gimp_progress_update (progress_end);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
0, 0, drawable->width, drawable->height);
}
/*
* 'load_image()' - Load a WMF image into a new image window.
*/
static gint32
load_image (const gchar *filename,
GError **error)
{
gint32 image;
gint32 layer;
GimpDrawable *drawable;
guchar *pixels;
GimpPixelRgn pixel_rgn;
guint width, height;
guint rowstride;
guint count = 0;
guint done = 0;
gpointer pr;
pixels = wmf_load_file (filename, &width, &height, error);
if (! pixels)
return -1;
rowstride = width * 4;
gimp_progress_init_printf (_("Opening '%s'"),
gimp_filename_to_utf8 (filename));
image = gimp_image_new (width, height, GIMP_RGB);
gimp_image_set_filename (image, filename);
gimp_image_set_resolution (image,
load_vals.resolution, load_vals.resolution);
layer = gimp_layer_new (image,
_("Rendered WMF"),
width, height,
GIMP_RGBA_IMAGE, 100, GIMP_NORMAL_MODE);
drawable = gimp_drawable_get (layer);
gimp_pixel_rgn_init (&pixel_rgn, drawable, 0, 0, width, height, TRUE, FALSE);
for (pr = gimp_pixel_rgns_register (1, &pixel_rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
const guchar *src = pixels + pixel_rgn.y * rowstride + pixel_rgn.x * 4;
guchar *dest = pixel_rgn.data;
gint y;
for (y = 0; y < pixel_rgn.h; y++)
{
memcpy (dest, src, pixel_rgn.w * pixel_rgn.bpp);
src += rowstride;
dest += pixel_rgn.rowstride;
}
done += pixel_rgn.h * pixel_rgn.w;
if (count++ % 16 == 0)
gimp_progress_update ((gdouble) done / (width * height));
}
g_free (pixels);
gimp_drawable_detach (drawable);
gimp_progress_update (1.0);
/* Tell GIMP to display the image.
*/
gimp_image_insert_layer (image, layer, -1, 0);
gimp_drawable_flush (drawable);
return image;
}
/*
* 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);
}
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;
}
}
}
/* --------------------------------------------
* p_attempt_locate_at_current_offset
* --------------------------------------------
*/
static void
p_attempt_locate_at_current_offset(Context *context, gint32 px, gint32 py)
{
GimpPixelRgn refPR;
GimpPixelRgn targetPR;
gpointer pr;
gint rx1, ry1, rWidth, rHeight;
gint tx1, ty1, tWidth, tHeight;
gint commonAreaWidth, commonAreaHeight;
gint fullShapeWidth, fullShapeHeight;
gint rWidthRequired, rHeightRequired;
gboolean isIntersect;
gint leftShapeRadius;
gint upperShapeRadius;
if (context->isFinishedFlag)
{
return;
}
fullShapeWidth = (2 * context->refShapeRadius);
fullShapeHeight = (2 * context->refShapeRadius);
/* calculate processing relevant intersecting reference / target rectangles */
isIntersect =
gimp_rectangle_intersect((context->refX - context->refShapeRadius) /* origin1 */
, (context->refY - context->refShapeRadius)
, fullShapeWidth /* width1 */
, fullShapeHeight /* height1 */
,0
,0
,context->refDrawable->width
,context->refDrawable->height
,&rx1
,&ry1
,&rWidth
,&rHeight
);
if (!isIntersect)
{
return;
}
leftShapeRadius = context->refX - rx1;
upperShapeRadius = context->refY - ry1;
isIntersect =
gimp_rectangle_intersect((px - leftShapeRadius) /* origin1 */
, (py - upperShapeRadius)
, rWidth /* width1 */
, rHeight /* height1 */
,0
,0
,context->targetDrawable->width
,context->targetDrawable->height
,&tx1
,&ty1
,&tWidth
,&tHeight
);
if (!isIntersect)
{
return;
}
commonAreaWidth = tWidth;
commonAreaHeight = tHeight;
// TODO test if 2/3 of the fullShapeWidth and fullShapeHeight is sufficient for usable results.
// alternative1: maybe require rWidth and rHeight
// alternative2: maybe require fullShapeWidth and fullShapeHeight
rWidthRequired = (fullShapeWidth * 2) / 3;
rHeightRequired = (fullShapeHeight * 2) / 3;
if ((commonAreaWidth < rWidthRequired)
|| (commonAreaHeight < rHeightRequired))
{
/* the common area is significant smaller than the reference shape
* skip the compare attempt in this case to avoid unpredictable results (near borders)
*/
return;
}
// if(gap_debug)
// {
// printf("p_attempt_locate_at: px: %04d py:%04d\n"
// " rx1:%04d ry1:%04d rWidth:%d rHeight:%d\n"
// " tx1:%04d ty1:%04d tWidth:%d tHeight:%d\n"
// " commonAreaWidth:%d commonAreaHeight:%d\n"
// ,(int)px
// ,(int)py
// ,(int)rx1
// ,(int)ry1
// ,(int)rWidth
// ,(int)rHeight
// ,(int)tx1
// ,(int)ty1
// ,(int)tWidth
// ,(int)tHeight
// ,(int)commonAreaWidth
// ,(int)commonAreaHeight
// );
// }
/* rest 'per offset' values in the context */
context->cancelAttemptFlag = FALSE;
context->sumDiffValue = 0;
context->involvedPixelCount = 0;
context->currentDistance = p_calculate_distance_to_ref_coord(context, px, py);
context->px = px;
context->py = py;
gimp_pixel_rgn_init (&refPR, context->refDrawable, rx1, ry1
, commonAreaWidth, commonAreaHeight
, FALSE /* dirty */
, FALSE /* shadow */
);
gimp_pixel_rgn_init (&targetPR, context->targetDrawable, tx1, ty1
, commonAreaWidth, commonAreaHeight
, FALSE /* dirty */
, FALSE /* shadow */
);
/* compare pixel areas in tiled portions via pixel region processing loops.
*/
for (pr = gimp_pixel_rgns_register (2, &refPR, &targetPR);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
if (context->cancelAttemptFlag)
{
break;
}
else
{
p_compare_regions(&refPR, &targetPR, context);
}
}
if (pr != NULL)
{
/* NOTE:
* early escaping from the loop with pr != NULL
* leads to memory leaks due to unbalanced tile ref/unref calls.
* the call to gap_gimp_pixel_rgns_unref cals unref on the current tile
* (in the same way as gimp_pixel_rgns_process does)
* but does not ref another available tile.
*/
gap_gimp_pixel_rgns_unref (pr);
}
if ((context->involvedPixelCount >= context->requiredPixelCount)
&& (context->sumDiffValue <= context->bestMatchingSumDiffValue))
{
if((context->sumDiffValue < context->bestMatchingSumDiffValue)
|| ( context->currentDistance < context->bestMatchingDistance))
{
context->bestMatchingSumDiffValue = context->sumDiffValue;
context->bestMatchingDistance = context->currentDistance;
context->bestMatchingPixelCount = context->involvedPixelCount;
context->bestX = px;
context->bestY = py;
if(gap_debug)
{
gdouble bestMatchingAvgColordiff;
bestMatchingAvgColordiff = p_calculate_average_colordiff(context->bestMatchingSumDiffValue
, context->bestMatchingPixelCount
);
printf("FOUND: bestX:%d bestY:%d squareDist:%d\n"
" sumDiffValues:%d pixelCount:%d bestMatchingAvgColordiff:%.5f\n"
, (int)context->bestX
, (int)context->bestY
, (int)context->bestMatchingDistance
, (int)context->bestMatchingSumDiffValue
, (int)context->bestMatchingPixelCount
, (float)bestMatchingAvgColordiff
);
}
if ((context->currentDistance <= context->veryNearDistance)
&& (context->sumDiffValue == 0))
{
/* stop all further attempts on exact matching area when near reference origin */
context->isFinishedFlag = TRUE;
}
}
}
} /* end p_attempt_locate_at_current_offset */
/*
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);
}
}
void
gimp_rgn_iterator_src_dest (GimpRgnIterator *iter,
GimpRgnFuncSrcDest func,
gpointer data)
{
GimpPixelRgn srcPR, destPR;
gint x1, y1, x2, y2;
gint bpp;
gpointer pr;
gint total_area;
gint area_so_far;
g_return_if_fail (iter != NULL);
x1 = iter->x1;
y1 = iter->y1;
x2 = iter->x2;
y2 = iter->y2;
total_area = (x2 - x1) * (y2 - y1);
area_so_far = 0;
gimp_pixel_rgn_init (&srcPR, iter->drawable, x1, y1, x2 - x1, y2 - y1,
FALSE, FALSE);
gimp_pixel_rgn_init (&destPR, iter->drawable, x1, y1, x2 - x1, y2 - y1,
TRUE, TRUE);
bpp = srcPR.bpp;
for (pr = gimp_pixel_rgns_register (2, &srcPR, &destPR);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
gint y;
guchar* src = srcPR.data;
guchar* dest = destPR.data;
for (y = srcPR.y; y < srcPR.y + srcPR.h; y++)
{
gint x;
guchar *s = src;
guchar *d = dest;
for (x = srcPR.x; x < srcPR.x + srcPR.w; x++)
{
func (x, y, s, d, bpp, data);
s += bpp;
d += bpp;
}
src += srcPR.rowstride;
dest += destPR.rowstride;
}
area_so_far += srcPR.w * srcPR.h;
gimp_progress_update ((gdouble) area_so_far / (gdouble) total_area);
}
gimp_drawable_flush (iter->drawable);
gimp_drawable_merge_shadow (iter->drawable->drawable_id, TRUE);
gimp_drawable_update (iter->drawable->drawable_id,
x1, y1, x2 - x1, y2 - y1);
}
