Adding upstream version 2.10.34.upstream/2.10.34upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 904 insertions, 0 deletions

diff --git a/plug-ins/common/van-gogh-lic.c b/plug-ins/common/van-gogh-lic.c
new file mode 100644
index 0000000..9bb5dc8
--- /dev/null
+++ b/plug-ins/common/van-gogh-lic.c
@@ -0,0 +1,904 @@
+/* LIC 0.14 -- image filter plug-in for GIMP
+ * Copyright (C) 1996 Tom Bech
+ *
+ * E-mail: tomb@gimp.org
+ * You can contact the original GIMP authors at gimp@xcf.berkeley.edu
+ *
+ * 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 3 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, see <https://www.gnu.org/licenses/>.
+ *
+ * In other words, you can't sue me for whatever happens while using this ;)
+ *
+ * Changes (post 0.10):
+ * -> 0.11: Fixed a bug in the convolution kernels (Tom).
+ * -> 0.12: Added Quartic's bilinear interpolation stuff (Tom).
+ * -> 0.13 Changed some UI stuff causing trouble with the 0.60 release, added
+ *         the (GIMP) tags and changed random() calls to rand() (Tom)
+ * -> 0.14 Ported to 0.99.11 (Tom)
+ *
+ * This plug-in implements the Line Integral Convolution (LIC) as described in
+ * Cabral et al. "Imaging vector fields using line integral convolution" in the
+ * Proceedings of ACM SIGGRAPH 93. Publ. by ACM, New York, NY, USA. p. 263-270.
+ * (See http://www8.cs.umu.se/kurser/TDBD13/VT00/extra/p263-cabral.pdf)
+ *
+ * Some of the code is based on code by Steinar Haugen (thanks!), the Perlin
+ * noise function is practically ripped as is :)
+ */
+
+#include "config.h"
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include "libgimp/stdplugins-intl.h"
+
+
+/************/
+/* Typedefs */
+/************/
+
+#define numx    40              /* Pseudo-random vector grid size */
+#define numy    40
+
+#define PLUG_IN_PROC   "plug-in-lic"
+#define PLUG_IN_BINARY "van-gogh-lic"
+#define PLUG_IN_ROLE   "gimp-van-gogh-lic"
+
+typedef enum
+{
+  LIC_HUE,
+  LIC_SATURATION,
+  LIC_BRIGHTNESS
+} LICEffectChannel;
+
+
+/*****************************/
+/* Global variables and such */
+/*****************************/
+
+static gdouble G[numx][numy][2];
+
+typedef struct
+{
+  gdouble  filtlen;
+  gdouble  noisemag;
+  gdouble  intsteps;
+  gdouble  minv;
+  gdouble  maxv;
+  gint     effect_channel;
+  gint     effect_operator;
+  gint     effect_convolve;
+  gint32   effect_image_id;
+} LicValues;
+
+static LicValues licvals;
+
+static gdouble l      = 10.0;
+static gdouble dx     =  2.0;
+static gdouble dy     =  2.0;
+static gdouble minv   = -2.5;
+static gdouble maxv   =  2.5;
+static gdouble isteps = 20.0;
+
+static gboolean source_drw_has_alpha = FALSE;
+
+static gint    effect_width, effect_height;
+static gint    border_x, border_y, border_w, border_h;
+
+static GtkWidget *dialog;
+
+/************************/
+/* Convenience routines */
+/************************/
+
+static void
+peek (GeglBuffer *buffer,
+      gint        x,
+      gint        y,
+      GimpRGB    *color)
+{
+  gegl_buffer_sample (buffer, x, y, NULL,
+                      color, babl_format ("R'G'B'A double"),
+                      GEGL_SAMPLER_NEAREST, GEGL_ABYSS_NONE);
+}
+
+static void
+poke (GeglBuffer *buffer,
+      gint        x,
+      gint        y,
+      GimpRGB    *color)
+{
+  gegl_buffer_set (buffer, GEGL_RECTANGLE (x, y, 1, 1), 0,
+                   babl_format ("R'G'B'A double"), color,
+                   GEGL_AUTO_ROWSTRIDE);
+}
+
+static gint
+peekmap (const guchar *image,
+         gint          x,
+         gint          y)
+{
+  while (x < 0)
+    x += effect_width;
+  x %= effect_width;
+
+  while (y < 0)
+    y += effect_height;
+  y %= effect_height;
+
+  return (gint) image[x + effect_width * y];
+}
+
+/*************/
+/* Main part */
+/*************/
+
+/***************************************************/
+/* Compute the derivative in the x and y direction */
+/* We use these convolution kernels:               */
+/*     |1 0 -1|     |  1   2   1|                  */
+/* DX: |2 0 -2| DY: |  0   0   0|                  */
+/*     |1 0 -1|     | -1  -2  -1|                  */
+/* (It's a variation of the Sobel kernels, really)  */
+/***************************************************/
+
+static gint
+gradx (const guchar *image,
+       gint          x,
+       gint          y)
+{
+  gint val = 0;
+
+  val = val +     peekmap (image, x-1, y-1);
+  val = val -     peekmap (image, x+1, y-1);
+
+  val = val + 2 * peekmap (image, x-1, y);
+  val = val - 2 * peekmap (image, x+1, y);
+
+  val = val +     peekmap (image, x-1, y+1);
+  val = val -     peekmap (image, x+1, y+1);
+
+  return val;
+}
+
+static gint
+grady (const guchar *image,
+       gint          x,
+       gint          y)
+{
+  gint val = 0;
+
+  val = val +     peekmap (image, x-1, y-1);
+  val = val + 2 * peekmap (image, x,   y-1);
+  val = val +     peekmap (image, x+1, y-1);
+
+  val = val -     peekmap (image, x-1, y+1);
+  val = val - 2 * peekmap (image, x,   y+1);
+  val = val -     peekmap (image, x+1, y+1);
+
+  return val;
+}
+
+/************************************/
+/* A nice 2nd order cubic spline :) */
+/************************************/
+
+static gdouble
+cubic (gdouble t)
+{
+  gdouble at = fabs (t);
+
+  return (at < 1.0) ? at * at * (2.0 * at - 3.0) + 1.0 : 0.0;
+}
+
+static gdouble
+omega (gdouble u,
+       gdouble v,
+       gint    i,
+       gint    j)
+{
+  while (i < 0)
+    i += numx;
+
+  while (j < 0)
+    j += numy;
+
+  i %= numx;
+  j %= numy;
+
+  return cubic (u) * cubic (v) * (G[i][j][0]*u + G[i][j][1]*v);
+}
+
+/*************************************************************/
+/* The noise function (2D variant of Perlins noise function) */
+/*************************************************************/
+
+static gdouble
+noise (gdouble x,
+       gdouble y)
+{
+  gint i, sti = (gint) floor (x / dx);
+  gint j, stj = (gint) floor (y / dy);
+
+  gdouble sum = 0.0;
+
+  /* Calculate the gdouble sum */
+  /* ======================== */
+
+  for (i = sti; i <= sti + 1; i++)
+    for (j = stj; j <= stj + 1; j++)
+      sum += omega ((x - (gdouble) i * dx) / dx,
+                    (y - (gdouble) j * dy) / dy,
+                    i, j);
+
+  return sum;
+}
+
+/*************************************************/
+/* Generates pseudo-random vectors with length 1 */
+/*************************************************/
+
+static void
+generatevectors (void)
+{
+  gdouble alpha;
+  gint i, j;
+  GRand *gr;
+
+  gr = g_rand_new();
+
+  for (i = 0; i < numx; i++)
+    {
+      for (j = 0; j < numy; j++)
+        {
+          alpha = g_rand_double_range (gr, 0, 2) * G_PI;
+          G[i][j][0] = cos (alpha);
+          G[i][j][1] = sin (alpha);
+        }
+    }
+
+  g_rand_free (gr);
+}
+
+/* A simple triangle filter */
+/* ======================== */
+
+static gdouble
+filter (gdouble u)
+{
+  gdouble f = 1.0 - fabs (u) / l;
+
+  return (f < 0.0) ? 0.0 : f;
+}
+
+/******************************************************/
+/* Compute the Line Integral Convolution (LIC) at x,y */
+/******************************************************/
+
+static gdouble
+lic_noise (gint    x,
+           gint    y,
+           gdouble vx,
+           gdouble vy)
+{
+  gdouble i = 0.0;
+  gdouble f1 = 0.0, f2 = 0.0;
+  gdouble u, step = 2.0 * l / isteps;
+  gdouble xx = (gdouble) x, yy = (gdouble) y;
+  gdouble c, s;
+
+  /* Get vector at x,y */
+  /* ================= */
+
+  c = vx;
+  s = vy;
+
+  /* Calculate integral numerically */
+  /* ============================== */
+
+  f1 = filter (-l) * noise (xx + l * c , yy + l * s);
+
+  for (u = -l + step; u <= l; u += step)
+    {
+      f2 = filter (u) * noise ( xx - u * c , yy - u * s);
+      i += (f1 + f2) * 0.5 * step;
+      f1 = f2;
+    }
+
+  i = (i - minv) / (maxv - minv);
+
+  i = CLAMP (i, 0.0, 1.0);
+
+  i = (i / 2.0) + 0.5;
+
+  return i;
+}
+
+static void
+getpixel (GeglBuffer *buffer,
+          GimpRGB    *p,
+          gdouble     u,
+          gdouble     v)
+{
+  register gint x1, y1, x2, y2;
+  gint width, height;
+  static GimpRGB pp[4];
+
+  width  = border_w;
+  height = border_h;
+
+  x1 = (gint)u;
+  y1 = (gint)v;
+
+  if (x1 < 0)
+    x1 = width - (-x1 % width);
+  else
+    x1 = x1 % width;
+
+  if (y1 < 0)
+    y1 = height - (-y1 % height);
+  else
+    y1 = y1 % height;
+
+  x2 = (x1 + 1) % width;
+  y2 = (y1 + 1) % height;
+
+  peek (buffer, x1, y1, &pp[0]);
+  peek (buffer, x2, y1, &pp[1]);
+  peek (buffer, x1, y2, &pp[2]);
+  peek (buffer, x2, y2, &pp[3]);
+
+  if (source_drw_has_alpha)
+    *p = gimp_bilinear_rgba (u, v, pp);
+  else
+    *p = gimp_bilinear_rgb (u, v, pp);
+}
+
+static void
+lic_image (GeglBuffer *buffer,
+           gint        x,
+           gint        y,
+           gdouble     vx,
+           gdouble     vy,
+           GimpRGB    *color)
+{
+  gdouble u, step = 2.0 * l / isteps;
+  gdouble xx = (gdouble) x, yy = (gdouble) y;
+  gdouble c, s;
+  GimpRGB col = { 0, 0, 0, 0 };
+  GimpRGB col1, col2, col3;
+
+  /* Get vector at x,y */
+  /* ================= */
+
+  c = vx;
+  s = vy;
+
+  /* Calculate integral numerically */
+  /* ============================== */
+
+  getpixel (buffer, &col1, xx + l * c, yy + l * s);
+
+  if (source_drw_has_alpha)
+    gimp_rgba_multiply (&col1, filter (-l));
+  else
+    gimp_rgb_multiply (&col1, filter (-l));
+
+  for (u = -l + step; u <= l; u += step)
+    {
+      getpixel (buffer, &col2, xx - u * c, yy - u * s);
+
+      if (source_drw_has_alpha)
+        {
+          gimp_rgba_multiply (&col2, filter (u));
+
+          col3 = col1;
+          gimp_rgba_add (&col3, &col2);
+          gimp_rgba_multiply (&col3, 0.5 * step);
+          gimp_rgba_add (&col, &col3);
+        }
+      else
+        {
+          gimp_rgb_multiply (&col2, filter (u));
+
+          col3 = col1;
+          gimp_rgb_add (&col3, &col2);
+          gimp_rgb_multiply (&col3, 0.5 * step);
+          gimp_rgb_add (&col, &col3);
+        }
+      col1 = col2;
+    }
+  if (source_drw_has_alpha)
+    gimp_rgba_multiply (&col, 1.0 / l);
+  else
+    gimp_rgb_multiply (&col, 1.0 / l);
+  gimp_rgb_clamp (&col);
+
+  *color = col;
+}
+
+static guchar *
+rgb_to_hsl (gint32            drawable_ID,
+            LICEffectChannel  effect_channel)
+{
+  GeglBuffer *buffer;
+  guchar     *themap, data[4];
+  gint        x, y;
+  GimpRGB     color;
+  GimpHSL     color_hsl;
+  gdouble     val = 0.0;
+  glong       maxc, index = 0;
+  GRand      *gr;
+
+  gr = g_rand_new ();
+
+  maxc = gimp_drawable_width (drawable_ID) * gimp_drawable_height (drawable_ID);
+
+  buffer = gimp_drawable_get_buffer (drawable_ID);
+
+  themap = g_new (guchar, maxc);
+
+  for (y = 0; y < border_h; y++)
+    {
+      for (x = 0; x < border_w; x++)
+        {
+          data[3] = 255;
+
+          gegl_buffer_sample (buffer, x, y, NULL,
+                              data, babl_format ("R'G'B'A u8"),
+                              GEGL_SAMPLER_NEAREST, GEGL_ABYSS_NONE);
+
+          gimp_rgba_set_uchar (&color, data[0], data[1], data[2], data[3]);
+          gimp_rgb_to_hsl (&color, &color_hsl);
+
+          switch (effect_channel)
+            {
+            case LIC_HUE:
+              val = color_hsl.h * 255;
+              break;
+            case LIC_SATURATION:
+              val = color_hsl.s * 255;
+              break;
+            case LIC_BRIGHTNESS:
+              val = color_hsl.l * 255;
+              break;
+            }
+
+          /* add some random to avoid unstructured areas. */
+          val += g_rand_double_range (gr, -1.0, 1.0);
+
+          themap[index++] = (guchar) CLAMP0255 (RINT (val));
+        }
+    }
+
+  g_object_unref (buffer);
+
+  g_rand_free (gr);
+
+  return themap;
+}
+
+
+static void
+compute_lic (gint32        drawable_ID,
+             const guchar *scalarfield,
+             gboolean      rotate)
+{
+  GeglBuffer *src_buffer;
+  GeglBuffer *dest_buffer;
+  gint        xcount, ycount;
+  GimpRGB     color;
+  gdouble     vx, vy, tmp;
+
+  src_buffer  = gimp_drawable_get_buffer (drawable_ID);
+  dest_buffer = gimp_drawable_get_shadow_buffer (drawable_ID);
+
+  for (ycount = 0; ycount < border_h; ycount++)
+    {
+      for (xcount = 0; xcount < border_w; xcount++)
+        {
+          /* Get derivative at (x,y) and normalize it */
+          /* ============================================================== */
+
+          vx = gradx (scalarfield, xcount, ycount);
+          vy = grady (scalarfield, xcount, ycount);
+
+          /* Rotate if needed */
+          if (rotate)
+            {
+              tmp = vy;
+              vy = -vx;
+              vx = tmp;
+            }
+
+          tmp = sqrt (vx * vx + vy * vy);
+          if (tmp >= 0.000001)
+            {
+              tmp = 1.0 / tmp;
+              vx *= tmp;
+              vy *= tmp;
+            }
+
+          /* Convolve with the LIC at (x,y) */
+          /* ============================== */
+
+          if (licvals.effect_convolve == 0)
+            {
+              peek (src_buffer, xcount, ycount, &color);
+
+              tmp = lic_noise (xcount, ycount, vx, vy);
+
+              if (source_drw_has_alpha)
+                gimp_rgba_multiply (&color, tmp);
+              else
+                gimp_rgb_multiply (&color, tmp);
+            }
+          else
+            {
+              lic_image (src_buffer, xcount, ycount, vx, vy, &color);
+            }
+
+          poke (dest_buffer, xcount, ycount, &color);
+        }
+
+      gimp_progress_update ((gfloat) ycount / (gfloat) border_h);
+    }
+
+  g_object_unref (src_buffer);
+  g_object_unref (dest_buffer);
+
+  gimp_progress_update (1.0);
+}
+
+static void
+compute_image (gint32 drawable_ID)
+{
+  guchar *scalarfield = NULL;
+
+  /* Get some useful info on the input drawable */
+  /* ========================================== */
+  if (! gimp_drawable_mask_intersect (drawable_ID,
+                                      &border_x, &border_y,
+                                      &border_w, &border_h))
+    return;
+
+  gimp_progress_init (_("Van Gogh (LIC)"));
+
+  if (licvals.effect_convolve == 0)
+    generatevectors ();
+
+  if (licvals.filtlen < 0.1)
+    licvals.filtlen = 0.1;
+
+  l = licvals.filtlen;
+  dx = dy = licvals.noisemag;
+  minv = licvals.minv / 10.0;
+  maxv = licvals.maxv / 10.0;
+  isteps = licvals.intsteps;
+
+  source_drw_has_alpha = gimp_drawable_has_alpha (drawable_ID);
+
+  effect_width =  gimp_drawable_width  (licvals.effect_image_id);
+  effect_height = gimp_drawable_height (licvals.effect_image_id);
+
+  switch (licvals.effect_channel)
+    {
+    case 0:
+      scalarfield = rgb_to_hsl (licvals.effect_image_id, LIC_HUE);
+      break;
+    case 1:
+      scalarfield = rgb_to_hsl (licvals.effect_image_id, LIC_SATURATION);
+      break;
+    case 2:
+      scalarfield = rgb_to_hsl (licvals.effect_image_id, LIC_BRIGHTNESS);
+      break;
+    }
+
+  compute_lic (drawable_ID, scalarfield, licvals.effect_operator);
+
+  g_free (scalarfield);
+
+  /* Update image */
+  /* ============ */
+
+  gimp_drawable_merge_shadow (drawable_ID, TRUE);
+  gimp_drawable_update (drawable_ID, border_x, border_y, border_w, border_h);
+
+  gimp_displays_flush ();
+}
+
+/**************************/
+/* Below is only UI stuff */
+/**************************/
+
+static gboolean
+effect_image_constrain (gint32    image_id,
+                        gint32    drawable_id,
+                        gpointer  data)
+{
+  return gimp_drawable_is_rgb (drawable_id);
+}
+
+static gboolean
+create_main_dialog (void)
+{
+  GtkWidget *vbox;
+  GtkWidget *hbox;
+  GtkWidget *frame;
+  GtkWidget *table;
+  GtkWidget *combo;
+  GtkObject *scale_data;
+  gint       row;
+  gboolean   run;
+
+  gimp_ui_init (PLUG_IN_BINARY, TRUE);
+
+  dialog = gimp_dialog_new (_("Van Gogh (LIC)"), PLUG_IN_ROLE,
+                            NULL, 0,
+                            gimp_standard_help_func, PLUG_IN_PROC,
+
+                            _("_Cancel"), GTK_RESPONSE_CANCEL,
+                            _("_OK"),     GTK_RESPONSE_OK,
+
+                            NULL);
+
+  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+                                           GTK_RESPONSE_OK,
+                                           GTK_RESPONSE_CANCEL,
+                                           -1);
+
+  gimp_window_set_transient (GTK_WINDOW (dialog));
+
+  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
+  gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
+  gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+                      vbox, TRUE, TRUE, 0);
+  gtk_widget_show (vbox);
+
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
+  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+  gtk_widget_show (hbox);
+
+  frame = gimp_int_radio_group_new (TRUE, _("Effect Channel"),
+                                    G_CALLBACK (gimp_radio_button_update),
+                                    &licvals.effect_channel,
+                                    licvals.effect_channel,
+
+                                    _("_Hue"),        0, NULL,
+                                    _("_Saturation"), 1, NULL,
+                                    _("_Brightness"), 2, NULL,
+
+                                    NULL);
+  gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
+  gtk_widget_show (frame);
+
+  frame = gimp_int_radio_group_new (TRUE, _("Effect Operator"),
+                                    G_CALLBACK (gimp_radio_button_update),
+                                    &licvals.effect_operator,
+                                    licvals.effect_operator,
+
+                                    _("_Derivative"), 0, NULL,
+                                    _("_Gradient"),   1, NULL,
+
+                                    NULL);
+  gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
+  gtk_widget_show (frame);
+
+  frame = gimp_int_radio_group_new (TRUE, _("Convolve"),
+                                    G_CALLBACK (gimp_radio_button_update),
+                                    &licvals.effect_convolve,
+                                    licvals.effect_convolve,
+
+                                    _("_With white noise"),  0, NULL,
+                                    _("W_ith source image"), 1, NULL,
+
+                                    NULL);
+  gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
+  gtk_widget_show (frame);
+
+  /* Effect image menu */
+  table = gtk_table_new (1, 2, FALSE);
+  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+  gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
+  gtk_widget_show (table);
+
+  combo = gimp_drawable_combo_box_new (effect_image_constrain, NULL);
+  gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo),
+                              licvals.effect_image_id,
+                              G_CALLBACK (gimp_int_combo_box_get_active),
+                              &licvals.effect_image_id);
+
+  gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
+                             _("_Effect image:"), 0.0, 0.5, combo, 2, TRUE);
+
+  table = gtk_table_new (5, 3, FALSE);
+  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+  gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
+  gtk_widget_show (table);
+
+  row = 0;
+
+  scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, row++,
+                                     _("_Filter length:"), 0, 6,
+                                     licvals.filtlen, 0.1, 64, 1.0, 8.0, 1,
+                                     TRUE, 0, 0,
+                                     NULL, NULL);
+  g_signal_connect (scale_data, "value-changed",
+                    G_CALLBACK (gimp_double_adjustment_update),
+                    &licvals.filtlen);
+
+  scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, row++,
+                                     _("_Noise magnitude:"), 0, 6,
+                                     licvals.noisemag, 1, 5, 0.1, 1.0, 1,
+                                     TRUE, 0, 0,
+                                     NULL, NULL);
+  g_signal_connect (scale_data, "value-changed",
+                    G_CALLBACK (gimp_double_adjustment_update),
+                    &licvals.noisemag);
+
+  scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, row++,
+                                     _("In_tegration steps:"), 0, 6,
+                                     licvals.intsteps, 1, 40, 1.0, 5.0, 1,
+                                     TRUE, 0, 0,
+                                     NULL, NULL);
+  g_signal_connect (scale_data, "value-changed",
+                    G_CALLBACK (gimp_double_adjustment_update),
+                    &licvals.intsteps);
+
+  scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, row++,
+                                     _("_Minimum value:"), 0, 6,
+                                     licvals.minv, -100, 0, 1, 10, 1,
+                                     TRUE, 0, 0,
+                                     NULL, NULL);
+  g_signal_connect (scale_data, "value-changed",
+                    G_CALLBACK (gimp_double_adjustment_update),
+                    &licvals.minv);
+
+  scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, row++,
+                                     _("M_aximum value:"), 0, 6,
+                                     licvals.maxv, 0, 100, 1, 10, 1,
+                                     TRUE, 0, 0,
+                                     NULL, NULL);
+  g_signal_connect (scale_data, "value-changed",
+                    G_CALLBACK (gimp_double_adjustment_update),
+                    &licvals.maxv);
+
+  gtk_widget_show (dialog);
+
+  run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
+
+  gtk_widget_destroy (dialog);
+
+  return run;
+}
+
+/*************************************/
+/* Set parameters to standard values */
+/*************************************/
+
+static void
+set_default_settings (void)
+{
+  licvals.filtlen          = 5;
+  licvals.noisemag         = 2;
+  licvals.intsteps         = 25;
+  licvals.minv             = -25;
+  licvals.maxv             = 25;
+  licvals.effect_channel   = 2;
+  licvals.effect_operator  = 1;
+  licvals.effect_convolve  = 1;
+  licvals.effect_image_id  = 0;
+}
+
+static void
+query (void)
+{
+  static const GimpParamDef args[] =
+  {
+    { GIMP_PDB_INT32,    "run-mode", "The run mode { RUN-INTERACTIVE (0) }"    },
+    { GIMP_PDB_IMAGE,    "image",    "Input image"    },
+    { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
+  };
+
+  gimp_install_procedure (PLUG_IN_PROC,
+                          N_("Special effects that nobody understands"),
+                          "No help yet",
+                          "Tom Bech & Federico Mena Quintero",
+                          "Tom Bech & Federico Mena Quintero",
+                          "Version 0.14, September 24 1997",
+                          N_("_Van Gogh (LIC)..."),
+                          "RGB*",
+                          GIMP_PLUGIN,
+                          G_N_ELEMENTS (args), 0,
+                          args, NULL);
+
+  gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Artistic");
+}
+
+static void
+run (const gchar      *name,
+     gint              nparams,
+     const GimpParam  *param,
+     gint             *nreturn_vals,
+     GimpParam       **return_vals)
+{
+  static GimpParam   values[1];
+  GimpRunMode        run_mode;
+  gint32             drawable_ID;
+  GimpPDBStatusType  status = GIMP_PDB_SUCCESS;
+
+  INIT_I18N ();
+  gegl_init (NULL, NULL);
+
+  *nreturn_vals = 1;
+  *return_vals  = values;
+
+  values[0].type          = GIMP_PDB_STATUS;
+  values[0].data.d_status = status;
+
+  /* Set default values */
+  /* ================== */
+
+  set_default_settings ();
+
+  /* Possibly retrieve data */
+  /* ====================== */
+
+  gimp_get_data (PLUG_IN_PROC, &licvals);
+
+  run_mode    = param[0].data.d_int32;
+  drawable_ID = param[2].data.d_drawable;
+
+  if (status == GIMP_PDB_SUCCESS)
+    {
+      /* Make sure that the drawable is RGBA or RGB color */
+      /* ================================================ */
+
+      if (gimp_drawable_is_rgb (drawable_ID))
+        {
+          switch (run_mode)
+            {
+            case GIMP_RUN_INTERACTIVE:
+              if (create_main_dialog ())
+                compute_image (drawable_ID);
+
+              gimp_set_data (PLUG_IN_PROC, &licvals, sizeof (LicValues));
+              break;
+
+            case GIMP_RUN_WITH_LAST_VALS:
+              compute_image (drawable_ID);
+              break;
+
+            default:
+              break;
+            }
+        }
+      else
+        {
+          status = GIMP_PDB_EXECUTION_ERROR;
+        }
+    }
+
+  values[0].data.d_status = status;
+}
+
+const GimpPlugInInfo PLUG_IN_INFO =
+{
+  NULL,  /* init_proc  */
+  NULL,  /* quit_proc  */
+  query, /* query_proc */
+  run,   /* run_proc   */
+};
+
+MAIN ()