Index: edge.c
===================================================================
RCS file: /cvs/gnome/gimp/plug-ins/common/edge.c,v
retrieving revision 1.33
diff -u -r1.33 edge.c
--- edge.c	17 Jul 2003 15:45:45 -0000	1.33
+++ edge.c	29 Jul 2003 20:14:47 -0000
@@ -35,11 +35,17 @@
  *    - It works with the alpha channel.
  */
 
+/*  29 July 2003   Dave Neary  <bolsh@gimp.org>
+ *  Added more edge detection routines, from the thin_line 
+ *  plug-in by iccii
+ */
+
 #include "config.h"
 
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include <gtk/gtk.h>
 
@@ -57,10 +63,27 @@
 
 #define TILE_CACHE_SIZE 48
 
+enum EdgeAlgorithm
+{
+  SOBEL,
+  PREWITT,
+  GRADIENT,
+  ROBERTS,
+  DIFFERENTIAL,
+  LAPLACE,
+};
+
+enum
+{
+  TWO_TONE,
+  GRAY,
+};
+
 typedef struct
 {
-  gdouble   amount;
-  gint      wrapmode;
+  gdouble  amount;
+  gint     edgemode;
+  gint     wrapmode;
 } EdgeVals;
 
 typedef struct
@@ -82,6 +105,13 @@
 static void      edge        (GimpDrawable     *drawable);
 static gint      edge_dialog (GimpDrawable     *drawable);
 
+static gint edge_detect  (guchar *data);
+static gint prewitt      (guchar *data);
+static gint gradient     (guchar *data);
+static gint roberts      (guchar *data);
+static gint differential (guchar *data);
+static gint laplace      (guchar *data);
+static gint sobel        (guchar *data);
 
 /***** Local vars *****/
 
@@ -95,7 +125,8 @@
 
 static EdgeVals evals =
 {
-  2.0,   /* amount   */
+  2.0,         /* amount   */
+  SOBEL,       /* Edge detection algorithm */
   PIXEL_SMEAR  /* wrapmode */
 };
 
@@ -117,13 +148,14 @@
     { GIMP_PDB_IMAGE, "image", "Input image (unused)" },
     { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
     { GIMP_PDB_FLOAT, "amount", "Edge detection amount" },
+    { GIMP_PDB_INT32, "edgemode", "Edge detection algorithm: { SOBEL (0), PREWITT (1), GRADIENT (2), ROBERTS (3),  DIFFERENTIAL (4), LAPLACE (5) }" }, 
     { GIMP_PDB_INT32, "wrapmode", "Edge detection behavior: { WRAP (0), SMEAR (1), BLACK (2) }" }
   };
 
   gchar *help_string =
-    "Perform edge detection on the contents of the specified drawable. It "
-    "applies, I think, convolution with 3x3 kernel. AMOUNT is an arbitrary "
-    "constant, WRAPMODE is like displace plug-in (useful for tilable image).";
+    "Perform edge detection on the contents of the specified drawable."
+    "AMOUNT is an arbitrary constant, WRAPMODE is like displace plug-in "
+    "(useful for tilable image).";
 
   gimp_install_procedure ("plug_in_edge",
 			  "Perform edge detection on the contents of the specified drawable",
@@ -176,12 +208,13 @@
 
     case GIMP_RUN_NONINTERACTIVE:
       /*  Make sure all the arguments are there!  */
-      if (nparams != 5)
+      if (nparams != 6)
 	status = GIMP_PDB_CALLING_ERROR;
       if (status == GIMP_PDB_SUCCESS)
 	{
 	  evals.amount   = param[3].data.d_float;
-	  evals.wrapmode = param[4].data.d_int32;
+	  evals.edgemode = param[4].data.d_int32;
+	  evals.wrapmode = param[5].data.d_int32;
 	}
       break;
 
@@ -241,14 +274,13 @@
   guchar *srcrow, *src;
   guchar *destrow, *dest;
   guchar pix00[4], pix01[4], pix02[4];
-  guchar pix10[4],/*pix11[4],*/ pix12[4];
+  guchar pix10[4], pix11[4], pix12[4];
   guchar pix20[4], pix21[4], pix22[4];
   glong width, height;
   gint alpha, has_alpha, chan;
   gint x, y;
   gint x1, y1, x2, y2;
-  glong sum1, sum2;
-  glong sum, scale;
+  gdouble amp;
   gint maxval;
   gint cur_progress;
   gint max_progress;
@@ -269,7 +301,7 @@
     alpha--;
 
   maxval = 255;
-  scale = (10 << 16) / evals.amount;
+  amp = evals.amount;
   wrapmode = evals.wrapmode;
 
   cur_progress = 0;
@@ -303,34 +335,17 @@
 		  */
 		  for (chan = 0; chan < alpha; chan++)
 		    {
-		      /*
-		       * PIX(1,1) is the current pixel, so
-		       * e.g. PIX(0,0) means 1 above and 1 left pixel.
-		       *
-		       * There were casting to `long' in GIMP 0.54
-		       * edge code, but I think `guchar' should be
-		       * extended to `int' with minus operators, so
-		       * there's no need to cast to `long'. Both sum1
-		       * and sum2 will be between -4*255 to 4*255
-		       *
-		       *    -- taka
-		       */
+                      /* get the 3x3 kernel into a guchar array, 
+                       * and send it to edge_detect */
+                      guchar kernel[9];
+                      int i,j;
 #define PIX(X,Y)  src[ (Y-1)*(int)src_rgn.rowstride + (X-1)*(int)src_rgn.bpp + chan ]
 		      /* make convolution */
-		      sum1 = (PIX(2,0) - PIX(0,0)) +
-			 2 * (PIX(2,1) - PIX(0,1)) +
-			     (PIX(2,2) - PIX(0,2));
-		      sum2 = (PIX(0,2) - PIX(0,0)) +
-			 2 * (PIX(1,2) - PIX(1,0)) +
-			     (PIX(2,2) - PIX(2,0));
+                      for(i = 0; i < 3; i++)
+                        for(j = 0; j < 3; j++)
+                          kernel[3*i + j] = PIX(i,j);
 #undef  PIX
-		      /* common job ... */
-		      sum = (glong) (sqrt((long) sum1 * sum1 + 
-					  (long) sum2 * sum2) + 0.5);
-		      sum = (sum * scale) >> 16;    /* arbitrary scaling factor */
-		      if (sum > maxval)
-			sum = maxval;
-		      dest[chan] = sum;
+		      dest[chan] = edge_detect(kernel);
 		    }
 		}
 	      else
@@ -339,11 +354,7 @@
 		  ** The kernel is not inside of the tile -- do slow
 		  ** version
 		  */
-		  /*
-		   * When the kernel intersects the boundary of the
-		   * image, get_tile_pixel() will (should) do the
-		   * right work with `wrapmode'.
-		   */
+                  
 		  gimp_pixel_fetcher_get_pixel2(pft, x-1, y-1, wrapmode, pix00);
 		  gimp_pixel_fetcher_get_pixel2(pft, x  , y-1, wrapmode, pix10);
 		  gimp_pixel_fetcher_get_pixel2(pft, x+1, y-1, wrapmode, pix20);
@@ -355,19 +366,19 @@
 
 		  for (chan = 0; chan < alpha; chan++)
 		    {
-		      /* make convolution */
-		      sum1 = (pix20[chan] - pix00[chan]) +
-			 2 * (pix21[chan] - pix01[chan]) +
-			     (pix22[chan] - pix20[chan]);
-		      sum2 = (pix02[chan] - pix00[chan]) +
-			 2 * (pix12[chan] - pix10[chan]) +
-			     (pix22[chan] - pix20[chan]);
-		      /* common job ... */
-		      sum = (glong) (sqrt ((long) sum1 * sum1 + 
-					   (long) sum2 * sum2) + 0.5);
-		      sum = (sum * scale) >> 16;  /* arbitrary scaling factor */
-		      if (sum > maxval) sum = maxval;
-		      dest[chan] = sum;
+                      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)
@@ -385,6 +396,253 @@
   gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
 }
 
+/* ***********************   Edge Detection   ******************** */
+
+
+/*
+ * Edge detect switcher function
+ */
+
+static gint
+edge_detect (guchar *data)
+{
+  gint ret;
+  switch (evals.edgemode)
+    {
+       case SOBEL:
+         ret = sobel (data);
+         break;
+       case PREWITT:
+         ret = prewitt (data);
+         break;
+       case GRADIENT:
+         ret = gradient (data);
+         break;
+       case ROBERTS:
+         ret = roberts (data);
+         break;
+       case DIFFERENTIAL:
+         ret = differential (data);
+         break;
+       case LAPLACE:
+         ret = laplace (data);
+         break;
+       default:
+         ret = -1;
+         break;
+    }
+  return ret;
+}
+
+
+/*
+ * Sobel Edge detector
+ */
+static gint
+sobel (guchar *data)
+{
+  gint    v_kernel[9] = {-1,  0,  1,
+                         -2,  0,  2,
+                         -1,  0,  1};
+  gint    h_kernel[9] = {-1, -2, -1,
+                          0,  0,  0,
+                          1,  2,  1};
+
+  gint i;
+  gint    v_grad, h_grad;
+  gdouble amp;
+
+  amp = evals.amount;
+
+  v_grad = 0;
+  h_grad = 0;
+  
+  for (i = 0; i < 9; i++)
+    { 
+      v_grad += v_kernel[i] * data[i];
+      h_grad += h_kernel[i] * data[i];
+    }
+  return CLAMP(sqrt (v_grad * v_grad * amp + 
+        h_grad * h_grad * amp), 0, 255);
+}
+
+/*
+ * Edge detector via template matting
+ *   -- Prewitt
+ */
+static gint
+prewitt (guchar *data)
+{
+  gint    k, max;
+  gint    m[8];
+  gdouble amp;
+
+  amp =  evals.amount ;
+
+  m[0] =   data [0] +   data [1] + data [2] 
+         + data [3] - 2*data [4] + data [5] 
+         - data [6] -   data [7] - data [8];
+  m[1] =   data [0] +   data [1] + data [2] 
+         + data [3] - 2*data [4] - data [5] 
+         + data [6] -   data [7] - data [8];
+  m[2] =   data [0] +   data [1] - data [2] 
+         + data [3] - 2*data [4] - data [5] 
+         + data [6] +   data [7] - data [8];
+  m[3] =   data [0] -   data [1] - data [2] 
+         + data [3] - 2*data [4] - data [5] 
+         + data [6] +   data [7] + data [8];
+  m[4] = - data [0] -   data [1] - data [2] 
+         + data [3] - 2*data [4] + data [5] 
+         + data [6] +   data [7] + data [8];
+  m[5] = - data [0] -   data [1] + data [2] 
+         - data [3] - 2*data [4] + data [5] 
+         + data [6] +   data [7] + data [8];
+  m[6] = - data [0] +   data [1] + data [2] 
+         - data [3] - 2*data [4] + data [5] 
+         - data [6] +   data [7] + data [8];
+  m[7] =   data [0] +   data [1] + data [2] 
+         - data [3] - 2*data [4] + data [5] 
+         - data [6] -   data [7] + data [8];
+
+  max = 0;
+  for (k = 0; k < 8; k++)
+    if (max < m[k])
+      max = m[k];
+  
+  return CLAMP(amp * max, 0, 255);
+}
+
+
+/*
+ * Gradient Edge detector
+ */
+static gint
+gradient (guchar *data)
+{
+  gint    v_kernel[9] = { 0,  0,  0,
+                          0,  4, -4,
+                          0,  0,  0};
+  gint    h_kernel[9] = { 0,  0,  0,
+                          0, -4,  0,
+                          0,  4,  0};
+
+  gint i;
+  gint    v_grad, h_grad;
+  gdouble amp;
+
+  amp = evals.amount;
+
+  v_grad = 0;
+  h_grad = 0;
+  
+  for (i = 0; i < 9; i++)
+    { 
+      v_grad += v_kernel[i] * data[i];
+      h_grad += h_kernel[i] * data[i];
+    }
+
+  return  CLAMP(sqrt (v_grad * v_grad * amp +
+                      h_grad * h_grad * amp), 0, 255);
+}
+
+
+
+/*
+ * Roberts Edge detector
+ */
+static gint
+roberts (guchar *data)
+{
+  gint    v_kernel[9] = {0,  0,  0,
+                         0,  4,  0,
+                         0,  0, -4};
+  gint    h_kernel[9] = {0,  0,  0,
+                         0,  0,  4,
+                         0, -4,  0};
+
+  gint i;
+  gint    v_grad, h_grad;
+  gdouble amp;
+
+  amp = evals.amount;
+
+  v_grad = 0;
+  h_grad = 0;
+  
+  for (i = 0; i < 9; i++)
+    { 
+      v_grad += v_kernel[i] * data[i];
+      h_grad += h_kernel[i] * data[i];
+    }
+
+  return  CLAMP(sqrt (v_grad * v_grad * amp +
+                      h_grad * h_grad * amp), 0, 255);
+
+}
+
+
+/*
+ * Differential Edge detector
+ */
+static gint
+differential (guchar *data)
+{
+  gint    v_kernel[9] = { 0,  0,  0,
+                          0,  2, -2,
+                          0,  2, -2};
+  gint    h_kernel[9] = { 0,  0,  0,
+                          0, -2, -2,
+                          0,  2,  2};
+
+
+  gint i;
+  gint    v_grad, h_grad;
+  gdouble amp;
+
+  amp = evals.amount;
+
+  v_grad = 0;
+  h_grad = 0;
+  
+  for (i = 0; i < 9; i++)
+    { 
+      v_grad += v_kernel[i] * data[i];
+      h_grad += h_kernel[i] * data[i];
+    }
+
+  return  CLAMP(sqrt (v_grad * v_grad * amp +
+                      h_grad * h_grad * amp), 0, 255);
+}
+
+
+/*
+ * Laplace Edge detector
+ */
+static gint
+laplace (guchar *data)
+{
+  gint    kernel[9] = { 1,  1,  1,
+                        1, -8,  1,
+                        1,  1,  1};
+
+  gint i;
+  gint    grad;
+  gdouble amp;
+
+  amp = evals.amount;
+
+  grad = 0;
+  
+  for (i = 0; i < 9; i++)
+    { 
+      grad += kernel[i] * data[i];
+    }
+
+  return  CLAMP(grad * amp, 0, 255);
+
+}
+
+
 /*******************************************************/
 /*                    Dialog                           */
 /*******************************************************/
@@ -430,6 +688,35 @@
   g_signal_connect (dlg, "destroy",
                     G_CALLBACK (gtk_main_quit),
                     NULL);
+
+  /*  compression  */
+  frame = gimp_radio_group_new2 (TRUE, _("Algorithm"),
+                                 G_CALLBACK (gimp_radio_button_update),
+                                 &evals.edgemode,
+                                 GINT_TO_POINTER (evals.edgemode),
+
+                                 _("_Sobel"),
+                                 GINT_TO_POINTER (SOBEL), NULL,
+
+                                 _("_Prewitt"),
+                                 GINT_TO_POINTER (PREWITT), NULL,
+
+                                 _("_Gradient"),
+                                 GINT_TO_POINTER (GRADIENT), NULL,
+
+                                 _("_Roberts"),
+                                 GINT_TO_POINTER (ROBERTS), NULL,
+
+                                 _("_Differential"),
+                                 GINT_TO_POINTER (DIFFERENTIAL), NULL,
+
+                                 _("_Laplace"),
+                                 GINT_TO_POINTER (LAPLACE), NULL,
+
+                                 NULL);
+
+  gtk_box_pack_start_defaults (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame);
+  gtk_widget_show (frame);
 
   /*  parameter settings  */
   frame = gtk_frame_new (_("Parameter Settings"));
