/* 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 "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 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 data); static void preview_update_preview (GtkWidget *widget, gpointer data); static void change_radius_callback (GtkWidget *widget, gpointer data); /* * 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 = { 3.0, /* inner radius */ 1.0, /* outer radius */ TRUE, /* normalize */ TRUE /* 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*, GRAY*", 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; GtkWidget *button; GtkWidget *vbox; Preview *preview; GimpUnit unit; gdouble xres; gdouble yres; gboolean run; 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); vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); preview = preview_new (drawable->drawable_id); gtk_box_pack_start (GTK_BOX (vbox), preview->vbox, FALSE, FALSE, 0); gtk_widget_show (preview->vbox); frame = gimp_frame_new (_("Smoothing parameters")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); /* 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_add (GTK_CONTAINER (frame), coord); gtk_widget_show (coord); gimp_size_entry_set_pixel_digits (GIMP_SIZE_ENTRY (coord), 1); g_signal_connect (coord, "value-changed", G_CALLBACK (change_radius_callback), preview); button = gtk_check_button_new_with_mnemonic (_("_Normalize")); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); 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), preview); gtk_widget_show (button); button = gtk_check_button_new_with_mnemonic (_("_Invert")); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); 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), preview); gtk_widget_show (button); 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 = drawable->drawable_id; gint32 layer1; gint32 layer2; gint width, height; gint x1, y1, x2, y2; guchar maxval = 255; gimp_drawable_mask_bounds (drawable_id, &x1, &y1, &x2, &y2); width = (x2 - x1); height = (y2 - y1); gimp_drawable_flush (drawable); layer1 = gimp_layer_copy (drawable_id); 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); 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); } if (dogvals.invert) gimp_invert (drawable_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; } } } 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; } } } 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 *box; GtkWidget *label; GtkWidget *hscroll, *vscroll; GtkWidget *table; GdkPixbuf *pixbuf; Preview *preview; gint width, height, bpp; gint w; gdouble x0, y0; preview = g_new (Preview, 1); preview->src_id = drawable_id; preview->vbox = box = gtk_vbox_new (FALSE, 0); 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 (box), table, FALSE, FALSE, 0); gtk_widget_show (table); /* "Source" label in top row, first column */ label = gtk_label_new (_("Source")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, 0, 0, 5); gtk_widget_show (label); /* GtkImage for peek at original in second row, first column */ preview->src_buffer = g_new (guchar, 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., height, 1., 10., w); g_signal_connect (preview->vadjust, "value-changed", G_CALLBACK (preview_update_src_view), preview); g_signal_connect (preview->vadjust, "value-changed", G_CALLBACK (preview_update_preview), 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., width, 1., 10., w); g_signal_connect (preview->hadjust, "value-changed", G_CALLBACK (preview_update_src_view), preview); g_signal_connect (preview->hadjust, "value-changed", G_CALLBACK (preview_update_preview), 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 */ label = gtk_label_new (_("Preview")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1, GTK_FILL, 0, 5, 0); gtk_widget_show (label); /* 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 = g_new (guchar, 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 = 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 (preview->previewimage); 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, preview); preview_update_preview (NULL, preview); return preview; } static void preview_update_src_view (GtkWidget *widget, gpointer data) { Preview *preview = data; GdkPixbuf *pixbuf; gint x0, y0; gint w = PREVIEWSIZE; gint bpp = gimp_drawable_bpp (preview->src_id); gboolean has_alpha = gimp_drawable_has_alpha (preview->src_id); gint k; guchar *pixdata; guchar *src; 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); /* it sucks that GdkPixbuf does not handle grayscale images */ if (bpp == 1 || bpp == 2) { pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, has_alpha, 8, w, w); pixdata = gdk_pixbuf_get_pixels (pixbuf); src = preview->src_buffer; for (k = 0; k < w * w; k++) { *(pixdata++) = *src; *(pixdata++) = *src; *(pixdata++) = *(src++); if (has_alpha) *(pixdata++) = *(src++); } } else { pixbuf = gdk_pixbuf_new_from_data (preview->src_buffer, GDK_COLORSPACE_RGB, has_alpha, 8, w, w, w*bpp, NULL, NULL); } gtk_image_set_from_pixbuf (GTK_IMAGE (preview->sourceimage), pixbuf); g_object_unref (pixbuf); } static void preview_update_preview (GtkWidget *widget, gpointer data) { Preview *preview = data; GdkPixbuf *pixbuf; gint x0, y0; gint w = PREVIEWSIZE; gint bpp = gimp_drawable_bpp (preview->preview_id); gint has_alpha = gimp_drawable_has_alpha (preview->preview_id); guchar *pixdata; guchar *src; gint k; dogvals.preview_x0 = x0 = gtk_adjustment_get_value (GTK_ADJUSTMENT (preview->hadjust)); dogvals.preview_y0 = y0 = gtk_adjustment_get_value (GTK_ADJUSTMENT (preview->vadjust)); 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); /* it sucks that GdkPixbuf does not handle grayscale */ if (bpp == 1 || bpp == 2) { pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, has_alpha, 8, w, w); pixdata = gdk_pixbuf_get_pixels (pixbuf); src = preview->preview_buffer; for (k = 0; k < w * w; k++) { *(pixdata++) = *src; *(pixdata++) = *src; *(pixdata++) = *(src++); if (has_alpha) { *(pixdata++) = *(src++); } } } else { pixbuf = gdk_pixbuf_new_from_data (preview->preview_buffer, GDK_COLORSPACE_RGB, has_alpha, 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 *widget, gpointer data) { 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 (widget, data); }