static void
sobel_preview_update (GimpPreview *preview)
{
sobel (gimp_drawable_preview_get_drawable (GIMP_DRAWABLE_PREVIEW (preview)),
bvals.horizontal,
bvals.vertical,
bvals.keep_sign,
preview);
}
static void
spread_preview_update (GimpPreview *preview,
GtkWidget *size)
{
GimpDrawable *drawable;
SpreadParam_t param;
gint x, y, bpp;
guchar *buffer, *dest;
gint x_off, y_off;
gint width, height;
drawable =
gimp_drawable_preview_get_drawable (GIMP_DRAWABLE_PREVIEW (preview));
param.pft = gimp_pixel_fetcher_new (drawable, FALSE);
param.gr = g_rand_new ();
param.x_amount = (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (size),
0) + 1) / 2;
param.y_amount = (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (size),
1) + 1) / 2;
param.width = drawable->width;
param.height = drawable->height;
gimp_preview_get_size (preview, &width, &height);
bpp = drawable->bpp;
dest = buffer = g_new (guchar, width * height * bpp);
gimp_preview_get_position (preview, &x_off, &y_off);
for (y = 0 ; y < height ; y++)
for (x = 0 ; x < width ; x++)
{
spread_func (x + x_off, y + y_off, dest, bpp, ¶m);
dest += bpp;
}
gimp_preview_draw_buffer (preview, buffer, width * bpp);
g_free (buffer);
g_rand_free (param.gr);
}
static void preview_update (GimpPreview *preview)
{
GimpDrawable *drawable;
gint x, y;
gint width, height;
GimpPixelRgn srcPR;
GimpPixelRgn destPR;
drawable = gimp_drawable_preview_get_drawable (GIMP_DRAWABLE_PREVIEW (preview));
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);
gimp_preview_get_position (preview, &x, &y);
gimp_preview_get_size (preview, &width, &height);
octave_region (&srcPR, &destPR, drawable->bpp, x, y, width, height);
gimp_pixel_rgn_init (&destPR, drawable, x, y, width, height, FALSE, TRUE);
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview), &destPR);
}
static void
preview_update (GimpPreview *preview)
{
GimpDrawable *drawable;
gint x1, x2;
gint y1, y2;
gint x, y;
gint width, height;
gint border;
GimpPixelRgn srcPR;
GimpPixelRgn destPR;
drawable =
gimp_drawable_preview_get_drawable (GIMP_DRAWABLE_PREVIEW (preview));
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);
gimp_preview_get_position (preview, &x, &y);
gimp_preview_get_size (preview, &width, &height);
/* enlarge the region to avoid artefacts at the edges of the preview */
border = 2.0 * c2g_params.radius + 0.5;
if (border > width/2) border = width/2; //Speed up preview
x1 = MAX (0, x - border);
y1 = MAX (0, y - border);
x2 = MIN (x + width + border, drawable->width);
y2 = MIN (y + height + border, drawable->height);
c2g_region (&srcPR, &destPR, drawable->bpp,
c2g_params.radius, c2g_params.amount, c2g_params.gamma,
x1, x2, y1, y2,
FALSE);
gimp_pixel_rgn_init (&destPR, drawable, x, y, width, height, FALSE, TRUE);
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview), &destPR);
}
static void
edge_preview_update (GimpPreview *preview)
{
/* drawable */
GimpDrawable *drawable;
glong bytes;
gint alpha;
gboolean has_alpha;
/* preview */
guchar *src = NULL; /* Buffer to hold source image */
guchar *render_buffer = NULL; /* Buffer to hold rendered image */
guchar *dest;
gint width; /* Width of preview widget */
gint height; /* Height of preview widget */
gint x1; /* Upper-left X of preview */
gint y1; /* Upper-left Y of preview */
GimpPixelRgn srcPR; /* Pixel regions */
/* algorithm */
gint x, y;
/* Get drawable info */
drawable =
gimp_drawable_preview_get_drawable (GIMP_DRAWABLE_PREVIEW (preview));
bytes = gimp_drawable_bpp (drawable->drawable_id);
alpha = bytes;
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
if (has_alpha)
alpha--;
/*
* Setup for filter...
*/
gimp_preview_get_position (preview, &x1, &y1);
gimp_preview_get_size (preview, &width, &height);
/* initialize pixel regions */
gimp_pixel_rgn_init (&srcPR, drawable,
x1, y1, width, height, FALSE, FALSE);
src = g_new (guchar, width * height * bytes);
render_buffer = g_new (guchar, width * height * bytes);
/* render image */
gimp_pixel_rgn_get_rect(&srcPR, src, x1, y1, width, height);
dest = render_buffer;
/* render algorithm */
for (y = 0 ; y < height ; y++)
for (x = 0 ; x < width ; x++)
{
gint chan;
for (chan = 0; chan < alpha; chan++)
{
guchar kernel[9];
#define SRC(X,Y) src[bytes * (CLAMP((X), 0, width-1) + \
width * CLAMP((Y), 0, height-1)) + chan]
kernel[0] = SRC (x - 1, y - 1);
kernel[1] = SRC (x - 1, y );
kernel[2] = SRC (x - 1, y + 1);
kernel[3] = SRC (x , y - 1);
kernel[4] = SRC (x , y );
kernel[5] = SRC (x , y + 1);
kernel[6] = SRC (x + 1, y - 1);
kernel[7] = SRC (x + 1, y );
kernel[8] = SRC (x + 1, y + 1);
#undef SRC
dest[chan] = edge_detect (kernel);
}
if (has_alpha)
dest[alpha] = src[bytes * (x + width * y) + alpha];
dest += bytes;
}
/*
* Draw the preview image on the screen...
*/
gimp_preview_draw_buffer (preview, render_buffer, width * bytes);
g_free (render_buffer);
g_free (src);
}
static void
preview_update (GimpPreview *preview)
{
GimpDrawable *drawable;
GimpPixelRgn src_rgn; /* Source image region */
guchar *src_ptr; /* Current source pixel */
guchar *dst_ptr; /* Current destination pixel */
intneg *neg_ptr; /* Current negative pixel */
gint i; /* Looping var */
gint y; /* Current location in image */
gint width; /* Byte width of the image */
gint x1, y1;
gint preview_width, preview_height;
guchar *preview_src, *preview_dst;
intneg *preview_neg;
gint img_bpp; /* Bytes-per-pixel in image */
void (*filter)(int, guchar *, guchar *, intneg *, intneg *, intneg *);
filter = NULL;
compute_luts();
gimp_preview_get_position (preview, &x1, &y1);
gimp_preview_get_size (preview, &preview_width, &preview_height);
drawable =
gimp_drawable_preview_get_drawable (GIMP_DRAWABLE_PREVIEW (preview));
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
preview_src = g_new (guchar, preview_width * preview_height * img_bpp);
preview_neg = g_new (intneg, preview_width * preview_height * img_bpp);
preview_dst = g_new (guchar, preview_width * preview_height * img_bpp);
gimp_pixel_rgn_init (&src_rgn, drawable,
x1, y1, preview_width, preview_height,
FALSE, FALSE);
width = preview_width * img_bpp;
/*
* Load the preview area...
*/
gimp_pixel_rgn_get_rect (&src_rgn, preview_src, x1, y1,
preview_width, preview_height);
for (i = width * preview_height, src_ptr = preview_src, neg_ptr = preview_neg;
i > 0;
i --)
*neg_ptr++ = neg_lut[*src_ptr++];
/*
* Select the filter...
*/
switch (img_bpp)
{
case 1:
filter = gray_filter;
break;
case 2:
filter = graya_filter;
break;
case 3:
filter = rgb_filter;
break;
case 4:
filter = rgba_filter;
break;
default:
g_error ("Programmer stupidity error: img_bpp is %d\n",
img_bpp);
}
/*
* Sharpen...
*/
memcpy (preview_dst, preview_src, width);
memcpy (preview_dst + width * (preview_height - 1),
preview_src + width * (preview_height - 1),
width);
for (y = preview_height - 2, src_ptr = preview_src + width,
neg_ptr = preview_neg + width + img_bpp,
dst_ptr = preview_dst + width;
y > 0;
y --, src_ptr += width, neg_ptr += width, dst_ptr += width)
(*filter)(preview_width, src_ptr, dst_ptr, neg_ptr - width,
neg_ptr, neg_ptr + width);
gimp_preview_draw_buffer (preview, preview_dst, preview_width * img_bpp);
g_free (preview_src);
g_free (preview_neg);
g_free (preview_dst);
}
