From 48095ce3fc28f15ac3cc507e4ffee1f3444d366b Mon Sep 17 00:00:00 2001 From: William Skaggs Date: Fri, 25 Jun 2004 20:19:54 +0000 Subject: [PATCH] Bill Skaggs * plug-ins/common/dog.c: added Difference of Gaussians edge detect plug-in. * plug-ins/common/plugin-defs.pl: * plug-ins/common/Makefile.am: added dog and regenerated Makefile. --- ChangeLog | 9 + plug-ins/common/.cvsignore | 1 + plug-ins/common/Makefile.am | 14 + plug-ins/common/dog.c | 1195 ++++++++++++++++++++++++++++++++ plug-ins/common/plugin-defs.pl | 1 + 5 files changed, 1220 insertions(+) create mode 100755 plug-ins/common/dog.c diff --git a/ChangeLog b/ChangeLog index ba1bfdd6c4..a706cd07ec 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,12 @@ +2004-06-25 Bill Skaggs + + * plug-ins/common/dog.c: added Difference of Gaussians edge + detect plug-in. + + * plug-ins/common/plugin-defs.pl: + * plug-ins/common/Makefile.am: added dog and regenerated + Makefile. + 2004-06-25 Michael Natterer * app/actions/context-actions.c: added GIMP_ACTION_SELECT_SET diff --git a/plug-ins/common/.cvsignore b/plug-ins/common/.cvsignore index e9e2097690..2b41b4e47a 100644 --- a/plug-ins/common/.cvsignore +++ b/plug-ins/common/.cvsignore @@ -37,6 +37,7 @@ destripe dicom diffraction displace +dog edge emboss engrave diff --git a/plug-ins/common/Makefile.am b/plug-ins/common/Makefile.am index cb12b83ad0..c958c362b7 100644 --- a/plug-ins/common/Makefile.am +++ b/plug-ins/common/Makefile.am @@ -63,6 +63,7 @@ libexec_PROGRAMS = \ dicom \ diffraction \ displace \ + dog \ edge \ emboss \ engrave \ @@ -637,6 +638,19 @@ displace_LDADD = \ $(RT_LIBS) \ $(INTLLIBS) +dog_SOURCES = \ + dog.c + +dog_LDADD = \ + $(libgimpui) \ + $(libgimpwidgets) \ + $(libgimp) \ + $(libgimpcolor) \ + $(libgimpbase) \ + $(GTK_LIBS) \ + $(RT_LIBS) \ + $(INTLLIBS) + edge_SOURCES = \ edge.c diff --git a/plug-ins/common/dog.c b/plug-ins/common/dog.c new file mode 100755 index 0000000000..ca4252b924 --- /dev/null +++ b/plug-ins/common/dog.c @@ -0,0 +1,1195 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +/* + * Gimp plug-in dog.c: (C) 2004 William Skaggs + * + * Edge detection using the "Difference of Gaussians" method. + * Finds edges by doing two Gaussian blurs with different radius, and + * subtracting the results. Blurring is done using code taken from + * gauss_rle.c (as of Gimp 2.1, incorporated into gauss.c). + */ +#include "config.h" + +#include +#include +#include + +#include + +#include +#include + +#include "libgimp/stdplugins-intl.h" + +typedef struct +{ + gdouble inner; + gdouble outer; + gboolean normalize; + gboolean invert; + gint32 preview_x0; + gint32 preview_y0; +} DoGValues; + +#define PREVIEWSIZE 128 + +typedef struct +{ + gint32 gimpimageid; + GimpDrawable *drawable; + gint32 src_id; + gint32 preview_id; + GtkWidget *vbox; + GtkWidget *sourceimage; + GtkWidget *previewimage; + GtkWidget *update_button; + guchar *src_buffer; + guchar *preview_buffer; + GimpPixelRgn src_rgn; + GimpPixelRgn preview_rgn; + GtkObject *hadjust; + GtkObject *vadjust; + gboolean update_policy; +} +Preview; + + +/* Declare local functions. + */ +static void query (void); +static void run (const gchar *name, + gint nparams, + const GimpParam *param, + gint *nreturn_vals, + GimpParam **return_vals); + +static gint dog_dialog (gint32 image_ID, + GimpDrawable *drawable); + +static void gauss_rle (GimpDrawable *drawable, + gdouble radius, + gint pass, + gboolean show_progress); + +static void compute_difference (GimpDrawable *drawable, + GimpDrawable *drawable1, + GimpDrawable *drawable2, + guchar *maxval); + +static void normalize (GimpDrawable *drawable, + guint maxval); + +static void invert (GimpDrawable *drawable); + +static void dog (GimpDrawable *drawable, + gdouble inner, + gdouble outer, + gboolean show_progress); + +static Preview* preview_new (gint32 drawable_id); + +static void preview_update_src_view (GtkWidget *widget, + gpointer d); + +static void preview_update_preview (GtkWidget *wg, + gpointer d); + +static void change_radius_callback (GtkWidget *wg, + gpointer d); + + + +/* + * Gaussian blur helper functions + */ +static gint * make_curve (gdouble sigma, + gint *length); +static void run_length_encode (guchar *src, + gint *dest, + gint bytes, + gint width); + + +GimpPlugInInfo PLUG_IN_INFO = +{ + NULL, /* init_proc */ + NULL, /* quit_proc */ + query, /* query_proc */ + run, /* run_proc */ +}; + +static DoGValues dogvals = +{ + 5.0, /* inner radius */ + 10.0, /* outer radius */ + TRUE, /* normalize */ + FALSE /* invert */ +}; + +GtkWidget *coord; + +MAIN () + +static void +query (void) +{ + static GimpParamDef args[] = + { + { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" }, + { GIMP_PDB_IMAGE, "image", "Input image" }, + { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }, + { GIMP_PDB_FLOAT, "inner", "Radius of inner gaussian blur (in pixels, > 0.0)" }, + { GIMP_PDB_FLOAT, "outer", "Radius of outer gaussian blur (in pixels, > 0.0)" }, + { GIMP_PDB_INT32, "normalize", "True, False" }, + { GIMP_PDB_INT32, "invert", "True, False" } + }; + + gimp_install_procedure ("plug_in_dog", + "Edge detection using difference of Gaussians.", + "Applies two Gaussian blurs to the drawable, and " + "subtracts the results. This is robust and widely " + "used method for detecting edges. Uses Gauss IIR " + "algorithm for the Gaussians.", + "Spencer Kimball, Peter Mattis, Sven Neumann, William Skaggs", + "Spencer Kimball, Peter Mattis, Sven Neumann, William Skaggs", + "1995-2004", + N_("Difference of Gaussians..."), + "RGB*", + GIMP_PLUGIN, + G_N_ELEMENTS (args), 0, + args, NULL); + + gimp_plugin_menu_register ("plug_in_dog", + N_("/Filters/Edge-Detect")); +} + +static void +run (const gchar *name, + gint nparams, + const GimpParam *param, + gint *nreturn_vals, + GimpParam **return_vals) +{ + static GimpParam values[1]; + gint32 image_ID; + GimpDrawable *drawable; + GimpRunMode run_mode; + GimpPDBStatusType status = GIMP_PDB_SUCCESS; + + run_mode = param[0].data.d_int32; + + INIT_I18N (); + + *nreturn_vals = 1; + *return_vals = values; + + values[0].type = GIMP_PDB_STATUS; + values[0].data.d_status = status; + + /* Get the specified image and drawable */ + image_ID = param[1].data.d_image; + drawable = gimp_drawable_get (param[2].data.d_drawable); + + if (strcmp (name, "plug_in_dog") == 0) + { + switch (run_mode) + { + case GIMP_RUN_INTERACTIVE: + /* Possibly retrieve data */ + gimp_get_data ("plug_in_dog", &dogvals); + + /* First acquire information with a dialog */ + if (! dog_dialog (image_ID, drawable)) + return; + break; + case GIMP_RUN_NONINTERACTIVE: + /* Make sure all the arguments are there! */ + if (nparams != 7) + status = GIMP_PDB_CALLING_ERROR; + if (status == GIMP_PDB_SUCCESS) + { + dogvals.inner = param[3].data.d_float; + dogvals.outer = param[4].data.d_float; + dogvals.normalize = param[5].data.d_int32; + dogvals.invert = param[6].data.d_int32; + } + if (status == GIMP_PDB_SUCCESS && + (dogvals.inner <= 0.0 && dogvals.outer <= 0.0)) + status = GIMP_PDB_CALLING_ERROR; + break; + + case GIMP_RUN_WITH_LAST_VALS: + /* Possibly retrieve data */ + gimp_get_data ("plug_in_dog", &dogvals); + break; + + default: + break; + } + } + else + status = GIMP_PDB_CALLING_ERROR; + + if (status == GIMP_PDB_SUCCESS) + { + /* Make sure that the drawable is gray or RGB color */ + if (gimp_drawable_is_rgb (drawable->drawable_id) || + gimp_drawable_is_gray (drawable->drawable_id)) + { + gimp_progress_init (_("DoG Edge Detect")); + + /* set the tile cache size so that the gaussian blur works well */ + gimp_tile_cache_ntiles (2 * + (MAX (drawable->width, drawable->height) / + gimp_tile_width () + 1)); + + /* run the Difference of Gaussians */ + gimp_image_undo_group_start (image_ID); + dog (drawable, dogvals.inner, dogvals.outer, TRUE); + + gimp_image_undo_group_end (image_ID); + + /* Store data */ + if (run_mode == GIMP_RUN_INTERACTIVE) + { + gimp_set_data ("plug_in_dog", + &dogvals, sizeof (DoGValues)); + } + if (run_mode != GIMP_RUN_NONINTERACTIVE) + gimp_displays_flush (); + } + else + { + g_message (_("Cannot operate on indexed color images.")); + status = GIMP_PDB_EXECUTION_ERROR; + } + + gimp_drawable_detach (drawable); + } + + values[0].data.d_status = status; +} + +static gint +dog_dialog (gint32 image_ID, + GimpDrawable *drawable) +{ + GtkWidget *dlg; + GtkWidget *frame; + GimpUnit unit; + gdouble xres; + gdouble yres; + gboolean run; + GtkWidget *button; + Preview *preview; + GtkWidget *hbox; + GtkWidget *vbox; + + gimp_ui_init ("dog", FALSE); + + dlg = gimp_dialog_new (_("DoG Edge Detect"), "dog", + NULL, 0, + gimp_standard_help_func, "plug-in-dog", + + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_OK, GTK_RESPONSE_OK, + + NULL); + + hbox = gtk_hbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + preview = preview_new (drawable->drawable_id); + gtk_box_pack_start (GTK_BOX (hbox), preview->vbox, FALSE, FALSE, 12); + gtk_widget_show (preview->vbox); + + /* parameter settings */ + vbox = gtk_vbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); + gtk_widget_show (vbox); + + frame = gtk_frame_new (_("Smoothing parameters")); + gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); + gtk_container_set_border_width (GTK_CONTAINER (frame), 6); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + + /* Get the image resolution and unit */ + gimp_image_get_resolution (image_ID, &xres, &yres); + unit = gimp_image_get_unit (image_ID); + + coord = gimp_coordinates_new (unit, "%a", TRUE, FALSE, -1, + GIMP_SIZE_ENTRY_UPDATE_SIZE, + + FALSE, + TRUE, + + _("_Radius 1:"), dogvals.inner, xres, + 0, 8 * MAX (drawable->width, drawable->height), + 0, 0, + + _("R_adius 2:"), dogvals.outer, yres, + 0, 8 * MAX (drawable->width, drawable->height), + 0, 0); + gtk_container_set_border_width (GTK_CONTAINER (coord), 4); + gtk_container_add (GTK_CONTAINER (frame), coord); + + gimp_size_entry_set_pixel_digits (GIMP_SIZE_ENTRY (coord), 1); + g_signal_connect (coord, "value-changed", + G_CALLBACK (change_radius_callback), + (gpointer)preview); + + button = gtk_check_button_new_with_mnemonic (_("_Normalize")); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 5); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), dogvals.normalize); + g_signal_connect (button, "toggled", + G_CALLBACK (gimp_toggle_button_update), + &dogvals.normalize); + g_signal_connect (button, "toggled", + G_CALLBACK (preview_update_preview), + (gpointer)preview); + gtk_widget_show (button); + + button = gtk_check_button_new_with_mnemonic (_("_Invert")); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 5); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), dogvals.invert); + g_signal_connect (button, "toggled", + G_CALLBACK (gimp_toggle_button_update), + &dogvals.invert); + g_signal_connect (button, "toggled", + G_CALLBACK (preview_update_preview), + (gpointer)preview); + gtk_widget_show (button); + + gtk_widget_show (coord); + gtk_widget_show (frame); + gtk_widget_show (dlg); + + run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); + + if (run) + { + dogvals.inner = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 0); + dogvals.outer = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 1); + } + + gtk_widget_destroy (dlg); + + gimp_image_delete (preview->gimpimageid); + + return run; +} + + +/* Convert from separated to premultiplied alpha, on a single scan line. */ +static void +multiply_alpha (guchar *buf, + gint width, + gint bytes) +{ + gint i, j; + gdouble alpha; + + for (i = 0; i < width * bytes; i += bytes) + { + alpha = buf[i + bytes - 1] * (1.0 / 255.0); + for (j = 0; j < bytes - 1; j++) + buf[i + j] *= alpha; + } +} + +/* Convert from premultiplied to separated alpha, on a single scan + line. */ +static void +separate_alpha (guchar *buf, + gint width, + gint bytes) +{ + gint i, j; + guchar alpha; + gdouble recip_alpha; + gint new_val; + + for (i = 0; i < width * bytes; i += bytes) + { + alpha = buf[i + bytes - 1]; + if (alpha != 0 && alpha != 255) + { + recip_alpha = 255.0 / alpha; + for (j = 0; j < bytes - 1; j++) + { + new_val = buf[i + j] * recip_alpha; + buf[i + j] = MIN (255, new_val); + } + } + } +} + +static void +dog (GimpDrawable *drawable, + gdouble inner, + gdouble outer, + gboolean show_progress) +{ + GimpDrawable *drawable1; + GimpDrawable *drawable2; + gint32 drawable_id; + gint32 layer1; + gint32 layer2; + gint width, height; + gint x1, y1, x2, y2; + guchar maxval = 255; + + drawable_id = drawable->drawable_id; + gimp_drawable_mask_bounds (drawable_id, &x1, &y1, &x2, &y2); + width = (x2 - x1); + height = (y2 - y1); + + gimp_drawable_flush (drawable); + + layer1 = gimp_layer_copy (drawable_id); + drawable1 = gimp_drawable_get (layer1); + + layer2 = gimp_layer_copy (drawable_id); + drawable2 = gimp_drawable_get (layer2); + + gauss_rle (drawable1, inner, 0, show_progress); + gauss_rle (drawable2, outer, 1, show_progress); + + _gimp_tile_cache_flush_drawable (drawable1); + _gimp_tile_cache_flush_drawable (drawable2); + + compute_difference (drawable, drawable1, drawable2, &maxval); + + gimp_drawable_detach (drawable1); + gimp_drawable_detach (drawable2); + + gimp_drawable_delete (layer1); + gimp_drawable_delete (layer2); + + gimp_drawable_flush (drawable); + gimp_drawable_merge_shadow (drawable_id, TRUE); + gimp_drawable_update (drawable_id, x1, y1, width, height); + + if (dogvals.normalize) + { + normalize (drawable, maxval); + gimp_drawable_flush (drawable); + gimp_drawable_merge_shadow (drawable_id, TRUE); + gimp_drawable_update (drawable_id, x1, y1, width, height); + _gimp_tile_cache_flush_drawable (drawable); + } + + if (dogvals.invert) + { + invert (drawable); + gimp_drawable_flush (drawable); + gimp_drawable_merge_shadow (drawable_id, TRUE); + gimp_drawable_update (drawable_id, x1, y1, width, height); + } + + +} + + +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; + gboolean has_alpha; + gint x1, y1, x2, y2; + + *maxval = 0; + + gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); + + width = (x2 - x1); + height = (y2 - y1); + + if (width < 1 || height < 1) + return; + + bpp = drawable->bpp; + has_alpha = gimp_drawable_has_alpha(drawable->drawable_id); + + gimp_pixel_rgn_init (&src1_rgn, + drawable1, 0, 0, drawable1->width, drawable1->height, + FALSE, FALSE); + gimp_pixel_rgn_init (&src2_rgn, + drawable2, 0, 0, drawable1->width, drawable1->height, + FALSE, FALSE); + gimp_pixel_rgn_init (&dest_rgn, + drawable, 0, 0, drawable->width, drawable->height, + TRUE, TRUE); + + for (pr = gimp_pixel_rgns_register (3, &src1_rgn, &src2_rgn, &dest_rgn); + pr != NULL; + pr = gimp_pixel_rgns_process (pr)) + { + guchar *src1 = src1_rgn.data; + guchar *src2 = src2_rgn.data; + guchar *dest = dest_rgn.data; + gint row = src1_rgn.y - y1; + + for (y = 0; y < src1_rgn.h; y++, row++) + { + guchar *s1 = src1; + guchar *s2 = src2; + guchar *d = dest; + gint col = src1_rgn.x - x1; + + for (x = 0; x < src1_rgn.w; x++, col++) + { + + if (has_alpha) + { + for (k = 0; k < bpp-1; k++) + { + d[k] = CLAMP0255 (s1[k] - s2[k]); + *maxval = MAX (d[k], *maxval); + } + } + else + { + for (k = 0; k < bpp; k++) + { + d[k] = CLAMP0255 (s1[k] - s2[k]); + *maxval = MAX (d[k], *maxval); + } + } + + s1 += bpp; + s2 += bpp; + d += bpp; + } + + src1 += src1_rgn.rowstride; + src2 += src2_rgn.rowstride; + dest += dest_rgn.rowstride; + } + } +} + + +static void +invert (GimpDrawable *drawable) +{ + GimpPixelRgn src_rgn, dest_rgn; + gint bpp; + gpointer pr; + gint x, y, k; + gboolean has_alpha; + gint x1, y1, x2, y2; + + 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] = 255 - s[k]; + } + else + { + for (k = 0; k < bpp; k++) + d[k] = 255 - s[k]; + } + + s += bpp; + d += bpp; + } + + src += src_rgn.rowstride; + dest += dest_rgn.rowstride; + } + } +} + +static void +normalize (GimpDrawable *drawable, + guint maxval) +{ + GimpPixelRgn src_rgn, dest_rgn; + gint bpp; + gpointer pr; + gint x, y, k; + gboolean has_alpha; + gint x1, y1, x2, y2; + gdouble factor; + + if (maxval == 0) + return; + else + factor = 255./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; + } + } +} + + +static void +gauss_rle (GimpDrawable *drawable, + gdouble radius, + gint pass, + gboolean show_progress) +{ + GimpPixelRgn src_rgn, dest_rgn; + gint width, height; + gint bytes; + gint has_alpha; + guchar *dest, *dp; + guchar *src, *sp; + gint *buf, *bb; + gint pixels; + gint total = 1; + gint x1, y1, x2, y2; + gint i, row, col, b; + gint start, end; + gdouble progress, max_progress; + gint *curve; + gint *sum = NULL; + gint val; + gint length; + gint initial_p, initial_m; + gdouble std_dev; + + if (radius <= 0.0) + return; + + gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); + + width = (x2 - x1); + height = (y2 - y1); + + if (width < 1 || height < 1) + return; + + bytes = drawable->bpp; + has_alpha = gimp_drawable_has_alpha(drawable->drawable_id); + + buf = g_new (gint, MAX (width, height) * 2); + + /* allocate buffers for source and destination pixels */ + src = g_new (guchar, MAX (width, height) * bytes); + dest = g_new (guchar, MAX (width, height) * bytes); + + gimp_pixel_rgn_init (&src_rgn, + drawable, 0, 0, drawable->width, drawable->height, + FALSE, FALSE); + gimp_pixel_rgn_init (&dest_rgn, + drawable, 0, 0, drawable->width, drawable->height, + TRUE, TRUE); + + progress = 0.0; + max_progress = 2 * width * height * radius; + + /* First the vertical pass */ + radius = fabs (radius) + 1.0; + std_dev = sqrt (-(radius * radius) / (2 * log (1.0 / 255.0))); + + curve = make_curve (std_dev, &length); + sum = g_new (gint, 2 * length + 1); + + sum[0] = 0; + + for (i = 1; i <= length*2; i++) + sum[i] = curve[i-length-1] + sum[i-1]; + sum += length; + + total = sum[length] - sum[-length]; + + for (col = 0; col < width; col++) + { + gimp_pixel_rgn_get_col (&src_rgn, src, col + x1, y1, (y2 - y1)); + if (has_alpha) + multiply_alpha (src, height, bytes); + + sp = src; + dp = dest; + + for (b = 0; b < bytes; b++) + { + initial_p = sp[b]; + initial_m = sp[(height-1) * bytes + b]; + + /* Determine a run-length encoded version of the row */ + run_length_encode (sp + b, buf, bytes, height); + + for (row = 0; row < height; row++) + { + start = (row < length) ? -row : -length; + end = (height <= (row + length) ? + (height - row - 1) : length); + + val = 0; + i = start; + bb = buf + (row + i) * 2; + + if (start != -length) + val += initial_p * (sum[start] - sum[-length]); + + while (i < end) + { + pixels = bb[0]; + i += pixels; + if (i > end) + i = end; + val += bb[1] * (sum[i] - sum[start]); + bb += (pixels * 2); + start = i; + } + + if (end != length) + val += initial_m * (sum[length] - sum[end]); + + dp[row * bytes + b] = val / total; + } + } + if (has_alpha) + separate_alpha (dest, height, bytes); + + gimp_pixel_rgn_set_col (&dest_rgn, dest, col + x1, y1, (y2 - y1)); + if (show_progress) + { + progress += height * radius; + if ((col % 5) == 0) + gimp_progress_update (0.5 * (pass + progress / max_progress)); + } + } + + /* prepare for the horizontal pass */ + gimp_pixel_rgn_init (&src_rgn, + drawable, 0, 0, drawable->width, drawable->height, + FALSE, TRUE); + + /* Now the horizontal pass */ + for (row = 0; row < height; row++) + { + gimp_pixel_rgn_get_row (&src_rgn, src, x1, row + y1, (x2 - x1)); + if (has_alpha) + multiply_alpha (src, width, bytes); + + sp = src; + dp = dest; + + for (b = 0; b < bytes; b++) + { + initial_p = sp[b]; + initial_m = sp[(width-1) * bytes + b]; + + /* Determine a run-length encoded version of the row */ + run_length_encode (sp + b, buf, bytes, width); + + for (col = 0; col < width; col++) + { + start = (col < length) ? -col : -length; + end = (width <= (col + length)) ? (width - col - 1) : length; + + val = 0; + i = start; + bb = buf + (col + i) * 2; + + if (start != -length) + val += initial_p * (sum[start] - sum[-length]); + + while (i < end) + { + pixels = bb[0]; + i += pixels; + if (i > end) + i = end; + val += bb[1] * (sum[i] - sum[start]); + bb += (pixels * 2); + start = i; + } + + if (end != length) + val += initial_m * (sum[length] - sum[end]); + + dp[col * bytes + b] = val / total; + } + } + if (has_alpha) + separate_alpha (dest, width, bytes); + + gimp_pixel_rgn_set_row (&dest_rgn, dest, x1, row + y1, (x2 - x1)); + if (show_progress) + { + progress += width * radius; + if ((row % 5) == 0) + gimp_progress_update (0.5 * (pass + progress / max_progress)); + } + } + + /* merge the shadow, update the drawable */ + gimp_drawable_flush (drawable); + gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); + gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1)); + + /* free buffers */ + g_free (buf); + g_free (src); + g_free (dest); +} + +/* + * The equations: g(r) = exp (- r^2 / (2 * sigma^2)) + * r = sqrt (x^2 + y ^2) + */ + +static gint * +make_curve (gdouble sigma, + gint *length) +{ + gint *curve; + gdouble sigma2; + gdouble l; + gint temp; + gint i, n; + + sigma2 = 2 * sigma * sigma; + l = sqrt (-sigma2 * log (1.0 / 255.0)); + + n = ceil (l) * 2; + if ((n % 2) == 0) + n += 1; + + curve = g_new (gint, n); + + *length = n / 2; + curve += *length; + curve[0] = 255; + + for (i = 1; i <= *length; i++) + { + temp = (gint) (exp (- (i * i) / sigma2) * 255); + curve[-i] = temp; + curve[i] = temp; + } + + return curve; +} + +static void +run_length_encode (guchar *src, + gint *dest, + gint bytes, + gint width) +{ + gint start; + gint i; + gint j; + guchar last; + + last = *src; + src += bytes; + start = 0; + + for (i = 1; i < width; i++) + { + if (*src != last) + { + for (j = start; j < i; j++) + { + *dest++ = (i - j); + *dest++ = last; + } + start = i; + last = *src; + } + src += bytes; + } + + for (j = start; j < i; j++) + { + *dest++ = (i - j); + *dest++ = last; + } +} + + + +static Preview* +preview_new (gint32 drawable_id) +{ + GtkWidget *box1, *tmpw; + GtkWidget *hscroll, *vscroll, *table; + gint width, height, bpp; + gint w; + GdkPixbuf *pixbuf; + gdouble x0, y0; + Preview *preview; + + preview = (Preview*)g_malloc (sizeof (Preview)); + preview->src_id = drawable_id; + + preview->vbox = box1 = gtk_vbox_new (FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (box1), 5); + + width = gimp_drawable_width (drawable_id); + height = gimp_drawable_height (drawable_id); + bpp = gimp_drawable_bpp (drawable_id); + w = PREVIEWSIZE; + + table = gtk_table_new (4, 5, FALSE); + gtk_box_pack_start (GTK_BOX (box1), table, FALSE, FALSE, 0); + gtk_widget_show (table); + + /* "Source" label in top row, first column */ + tmpw = gtk_label_new (_("Source")); + gtk_table_attach (GTK_TABLE (table), tmpw, 0, 1, 0, 1, GTK_FILL, 0, 0, 5); + gtk_widget_show (tmpw); + + /* GtkImage for peek at original in second row, first column */ + preview->src_buffer = (guchar *)g_malloc (bpp*w*w); + gimp_pixel_rgn_init (&preview->src_rgn, gimp_drawable_get (drawable_id), + 0, 0, width, height, FALSE, FALSE); + gimp_pixel_rgn_get_rect (&preview->src_rgn, preview->src_buffer, 0, 0, w, w); + pixbuf = gdk_pixbuf_new_from_data (preview->src_buffer, + GDK_COLORSPACE_RGB, + gimp_drawable_has_alpha (drawable_id), + 8, w, w, + bpp*w, + NULL, NULL); + preview->sourceimage = gtk_image_new_from_pixbuf (pixbuf); + g_object_unref (pixbuf); + gtk_table_attach (GTK_TABLE(table), preview->sourceimage, 0, 1, 1, 2, 0, 0, 0, 0); + gtk_widget_show (preview->sourceimage); + + /* vertical scrollbar in second row, second column */ + y0 = CLAMP (dogvals.preview_y0, 0., (gdouble)(height - w)); + preview->vadjust = gtk_adjustment_new (y0, 0., (gdouble)height, 1., 10., (gdouble)w); + g_signal_connect (preview->vadjust, "value-changed", + G_CALLBACK (preview_update_src_view), (gpointer)preview); + g_signal_connect (preview->vadjust, "value-changed", + G_CALLBACK (preview_update_preview), (gpointer)preview); + vscroll = gtk_vscrollbar_new (GTK_ADJUSTMENT (preview->vadjust)); + gtk_range_set_update_policy (GTK_RANGE (vscroll), GTK_UPDATE_DISCONTINUOUS); + gtk_table_attach (GTK_TABLE (table), vscroll, 1, 2, 1, 2, 0, GTK_FILL, 0, 0); + gtk_widget_show (vscroll); + + /* horizontal scrollbar in third row, first column */ + x0 = CLAMP (dogvals.preview_x0, 0., (gdouble)(width - w)); + preview->hadjust = gtk_adjustment_new (x0, 0., (gdouble)width, 1., 10., (gdouble)w); + g_signal_connect (preview->hadjust, "value-changed", + G_CALLBACK (preview_update_src_view), (gpointer)preview); + g_signal_connect (preview->hadjust, "value-changed", + G_CALLBACK (preview_update_preview), (gpointer)preview); + hscroll = gtk_hscrollbar_new (GTK_ADJUSTMENT (preview->hadjust)); + gtk_range_set_update_policy (GTK_RANGE (hscroll), GTK_UPDATE_DISCONTINUOUS); + gtk_table_attach (GTK_TABLE (table), hscroll, 0, 1, 2, 3, GTK_FILL, 0, 0, 0); + gtk_widget_show (hscroll); + + gtk_table_set_col_spacing (GTK_TABLE (table), 2, 12); + + /* "Preview" label in first row, third column */ + tmpw = gtk_label_new (_("Preview")); + gtk_table_attach (GTK_TABLE (table), tmpw, 2, 3, 0, 1, GTK_FILL, 0, 5, 0); + gtk_widget_show (tmpw); + + + /* set up gimp drawable for rendering preview into */ + preview->gimpimageid = gimp_image_new (w, w, GIMP_RGB); + /*gimp_image_undo_disable (preview->gimpimageid);*/ + preview->preview_id = gimp_layer_new (preview->gimpimageid, "preview", w, w, + gimp_drawable_type (preview->src_id), + 100, + GIMP_NORMAL_MODE); + preview->drawable = gimp_drawable_get (preview->preview_id); + gimp_image_add_layer (preview->gimpimageid, preview->preview_id, 0); + gimp_layer_set_offsets (preview->preview_id, 0, 0); + gimp_pixel_rgn_init (&preview->preview_rgn, preview->drawable, + 0, 0, w, w, TRUE, TRUE); + bpp = gimp_drawable_bpp (preview->preview_id); + gimp_tile_cache_ntiles (2 * (1 + preview->drawable->ntile_rows) + * (1 + preview->drawable->ntile_cols)); + + /* GtkImage for preview in second row, third column */ + preview->preview_buffer = (guchar *)g_malloc (bpp*w*w); + pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, + gimp_drawable_has_alpha (preview->preview_id), + 8, w, w); + gdk_pixbuf_fill (pixbuf, 0x000000ff /* opaque black */); + preview->previewimage = tmpw = gtk_image_new_from_pixbuf (pixbuf); + g_object_unref (pixbuf); + gtk_table_attach (GTK_TABLE (table), preview->previewimage, + 2, 3, 1, 2, 0, 0, 5, 0); + gtk_widget_show (tmpw); + + gtk_adjustment_set_value (GTK_ADJUSTMENT (preview->hadjust), dogvals.preview_x0); + gtk_adjustment_set_value (GTK_ADJUSTMENT (preview->vadjust), dogvals.preview_y0); + + preview_update_src_view (preview->vbox, (gpointer)preview); + preview_update_preview (NULL, (gpointer)preview); + + return preview; +} + + +static void +preview_update_src_view (GtkWidget *widget, + gpointer d) +{ + gint x0, y0; + gint w = PREVIEWSIZE; + GdkPixbuf *pixbuf; + Preview *preview = (Preview*)d; + + x0 = gtk_adjustment_get_value (GTK_ADJUSTMENT (preview->hadjust)); + y0 = gtk_adjustment_get_value (GTK_ADJUSTMENT (preview->vadjust)); + gimp_pixel_rgn_get_rect (&preview->src_rgn, preview->src_buffer, + x0, y0, w, w); + pixbuf = gdk_pixbuf_new_from_data (preview->src_buffer, + GDK_COLORSPACE_RGB, + gimp_drawable_has_alpha (preview->src_id), + 8, w, w, + w*gimp_drawable_bpp (preview->src_id), + NULL, NULL); + gtk_image_set_from_pixbuf (GTK_IMAGE (preview->sourceimage), pixbuf); + g_object_unref (pixbuf); +} + + +static void +preview_update_preview (GtkWidget *wg, + gpointer d) +{ + gint x0, y0; + gint w = PREVIEWSIZE; + GdkPixbuf *pixbuf; + gint bpp; + Preview *preview = (Preview*)d; + + dogvals.preview_x0 = x0 + = gtk_adjustment_get_value (GTK_ADJUSTMENT (preview->hadjust)); + dogvals.preview_y0 = y0 + = gtk_adjustment_get_value (GTK_ADJUSTMENT (preview->vadjust)); + bpp = gimp_drawable_bpp (preview->preview_id); + + + gimp_pixel_rgn_get_rect (&preview->src_rgn, preview->preview_buffer, + x0, y0, w, w); + gimp_pixel_rgn_set_rect (&preview->preview_rgn, preview->preview_buffer, + 0, 0, w, w); + gimp_drawable_flush (preview->drawable); + gimp_drawable_merge_shadow (preview->preview_id, TRUE); + gimp_drawable_update (preview->preview_id, 0, 0, w, w); + + dog (preview->drawable, dogvals.inner, dogvals.outer, FALSE); + + gimp_pixel_rgn_get_rect (&preview->preview_rgn, preview->preview_buffer, + 0, 0, w, w); + pixbuf = gdk_pixbuf_new_from_data (preview->preview_buffer, + GDK_COLORSPACE_RGB, + gimp_drawable_has_alpha (preview->preview_id), + 8, w, w, + w*bpp, + NULL, NULL); + gtk_image_set_from_pixbuf (GTK_IMAGE (preview->previewimage), pixbuf); + g_object_unref (pixbuf); +} + +static void +change_radius_callback (GtkWidget *wg, + gpointer d) +{ + dogvals.inner = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 0); + dogvals.outer = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 1); + + preview_update_preview (wg, d); +} + + diff --git a/plug-ins/common/plugin-defs.pl b/plug-ins/common/plugin-defs.pl index bf36d273bc..ef420d333e 100644 --- a/plug-ins/common/plugin-defs.pl +++ b/plug-ins/common/plugin-defs.pl @@ -34,6 +34,7 @@ 'dicom' => { libdep => 'gtk', ui => 1 }, 'diffraction' => { libdep => 'gtk', ui => 1 }, 'displace' => { libdep => 'gtk', ui => 1 }, + 'dog' => { libdep => 'gtk', ui => 1 }, 'edge' => { libdep => 'gtk', ui => 1 }, 'emboss' => { libdep => 'gtk', ui => 1 }, 'engrave' => { libdep => 'gtk', ui => 1 },