Mostly minor code clean-up. Fixed one memory leak.

ChangeLog

@@ -1,3 +1,9 @@
+2003-01-30  Maurits Rijk  <lpeek.mrijk@consunet.nl>
+
+	* plug-ins/common/c_astretch.c
+	* plug-ins/common/edge.c
+	* plug-ins/common/cubism.c: code clean-up, plugged a few memory leaks
+
 2003-01-30  Sven Neumann  <sven@gimp.org>
 
 	* libgimp/gimpcompat.h: removed GIMP_ENABLE_COMPAT_CRUFT guards.
@@ -89,6 +95,11 @@
 	* app/gui/module-browser.c: pack the button box non-expanding,
 	removed cruft from the ModuleBrowser struct.
 
+2003-01-28  Maurits Rijk  <lpeek.mrijk@consunet.nl>
+
+	* plug-ins/common/color_enhance.c: 
+	* plug-ins/common/gradmap.c: minor code clean-up
+
 2003-01-28  Tor Lillqvist  <tml@iki.fi>
 
 	* libgimp/gimpui.def: Add missing entry points.

plug-ins/common/c_astretch.c

@@ -58,6 +58,7 @@ GimpPlugInInfo PLUG_IN_INFO =
   run,   /* run_proc   */
 };
 
+static GimpRunMode run_mode;
 
 MAIN ()
 
@@ -100,7 +101,6 @@ run (gchar      *name,
 {
   static GimpParam   values[1];
   GimpDrawable      *drawable;
-  GimpRunMode    run_mode;
   GimpPDBStatusType  status = GIMP_PDB_SUCCESS;
 
   gint32 image_ID;
@@ -146,9 +146,8 @@ run (gchar      *name,
   gimp_drawable_detach (drawable);
 }
 
-
 static void
-indexed_c_astretch (gint32 image_ID)  /* a.d.m. */
+indexed_c_astretch (gint32 image_ID)
 {
   guchar *cmap;
   gint ncols,i;
@@ -185,127 +184,73 @@ indexed_c_astretch (gint32 image_ID)  /* a.d.m. */
   gimp_image_set_cmap (image_ID, cmap, ncols);
 }
 
+typedef struct {
+  gint		alpha;
+  guchar  	lut[256][3];
+  guchar  	min[3];
+  guchar	max[3];
+  gboolean 	has_alpha;
+} AutoStretchParam_t;
+
+static void 
+find_min_max (guchar *src, gint bpp, gpointer data)
+{
+  AutoStretchParam_t *param = (AutoStretchParam_t*) data;
+  gint b;
+
+  for (b = 0; b < param->alpha; b++)
+    {
+      if (!param->has_alpha || src[param->alpha])
+	{
+	  if (src[b] < param->min[b])
+	    param->min[b] = src[b];
+	  if (src[b] > param->max[b])
+	    param->max[b] = src[b];
+	}
+    }
+}
+
+static void
+c_astretch_func (guchar *src, guchar *dest, gint bpp, gpointer data)
+{
+  AutoStretchParam_t *param = (AutoStretchParam_t*) data;
+  gint b;
+
+  for (b = 0; b < param->alpha; b++)
+    dest[b] = param->lut[src[b]][b];
+  
+  if (param->has_alpha)
+    dest[param->alpha] = src[param->alpha];
+}
 
 static void
 c_astretch (GimpDrawable *drawable)
 {
-  GimpPixelRgn src_rgn, dest_rgn;
+  AutoStretchParam_t param;
-  guchar *src, *s;
+  gint b;
-  guchar *dest, *d;
-  guchar  min[3], max[3];
-  guchar  range;
-  guchar  lut[256][3];
-  gint    progress, max_progress;
-  gint    has_alpha, alpha;
-  gint    x1, y1, x2, y2;
-  gint    x, y, b;
-  gpointer pr;
 
-  /* Get selection area */
+  param.has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
-  gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
+  param.alpha = (param.has_alpha) ? drawable->bpp - 1 : drawable->bpp;
-  has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
-  alpha = (has_alpha) ? drawable->bpp - 1 : drawable->bpp;
-
-  /* Initialize progress */
-  progress = 0;
-  max_progress = (x2 - x1) * (y2 - y1) * 2;
 
   /* Get minimum and maximum values for each channel */
-  min[0] = min[1] = min[2] = 255;
+  param.min[0] = param.min[1] = param.min[2] = 255;
-  max[0] = max[1] = max[2] = 0;
+  param.max[0] = param.max[1] = param.max[2] = 0;
 
-  gimp_pixel_rgn_init (&src_rgn, drawable,
+  gimp_rgn_iterate1 (drawable, run_mode, find_min_max, &param);
-		       x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE);
-
-  for (pr = gimp_pixel_rgns_register (1, &src_rgn);
-       pr != NULL;
-       pr = gimp_pixel_rgns_process (pr))
-    {
-      src = src_rgn.data;
-
-      for (y = 0; y < src_rgn.h; y++)
-	{
-	  s = src;
-	  for (x = 0; x < src_rgn.w; x++)
-	    {
-	      for (b = 0; b < alpha; b++)
-		{
-		  if (!has_alpha || (has_alpha && s[alpha]))
-		    {
-		      if (s[b] < min[b])
-			min[b] = s[b];
-		      if (s[b] > max[b])
-			max[b] = s[b];
-		    }
-		}
-
-	      s += src_rgn.bpp;
-	    }
-
-	  src += src_rgn.rowstride;
-	}
-
-      /* Update progress */
-      progress += src_rgn.w * src_rgn.h;
-
-      gimp_progress_update ((double) progress / (double) max_progress);
-    }
 
   /* Calculate LUTs with stretched contrast */
-  for (b = 0; b < alpha; b++)
+  for (b = 0; b < param.alpha; b++)
     {
-      range = max[b] - min[b];
+      gint range = param.max[b] - param.min[b];
+      gint x;
 
       if (range != 0)
-	for (x = min[b]; x <= max[b]; x++)
+	for (x = param.min[b]; x <= param.max[b]; x++)
-	  lut[x][b] = 255 * (x - min[b]) / range;
+	  param.lut[x][b] = 255 * (x - param.min[b]) / range;
       else
-	lut[min[b]][b] = min[b];
+	param.lut[param.min[b]][b] = param.min[b];
     }
 
-  /* Now substitute pixel vales */
+  gimp_rgn_iterate2 (drawable, run_mode, c_astretch_func, &param);
-  gimp_pixel_rgn_init (&src_rgn, drawable,
-		       x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE);
-  gimp_pixel_rgn_init (&dest_rgn, drawable,
-		       x1, y1, (x2 - x1), (y2 - y1), TRUE, TRUE);
-
-  for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
-       pr != NULL;
-       pr = gimp_pixel_rgns_process (pr))
-    {
-      src = src_rgn.data;
-      dest = dest_rgn.data;
-
-      for (y = 0; y < src_rgn.h; y++)
-	{
-	  s = src;
-	  d = dest;
-
-	  for (x = 0; x < src_rgn.w; x++)
-	    {
-	      for (b = 0; b < alpha; b++)
-		d[b] = lut[s[b]][b];
-
-	      if (has_alpha)
-		d[alpha] = s[alpha];
-
-	      s += src_rgn.bpp;
-	      d += dest_rgn.bpp;
-	    }
-
-	  src += src_rgn.rowstride;
-	  dest += dest_rgn.rowstride;
-
-	}
-
-      /* Update progress */
-      progress += src_rgn.w * src_rgn.h;
-
-      gimp_progress_update ((double) progress / (double) max_progress);
-    }
-
-  /*  update the region  */
-  gimp_drawable_flush (drawable);
-  gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
-  gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
 }
+

plug-ins/common/color_enhance.c

@@ -39,6 +39,7 @@
 
 #include "libgimp/stdplugins-intl.h"
 
+static GimpRunMode    run_mode;
 
 /* Declare local functions.
  */
@@ -104,7 +105,6 @@ run (gchar      *name,
 {
   static GimpParam   values[1];
   GimpDrawable      *drawable;
-  GimpRunMode    run_mode;
   GimpPDBStatusType  status = GIMP_PDB_SUCCESS;
 
   gint32 image_ID;
@@ -149,222 +149,146 @@ run (gchar      *name,
   gimp_drawable_detach (drawable);
 }
 
+static gdouble
+get_v (const guchar *src)
+{
+  gdouble h, z, v;
+  gint c, m, y;
+  gint k;
+  guchar map[3];
+  
+  c = 255 - src[0];
+  m = 255 - src[1];
+  y = 255 - src[2];
+      
+  k = c;
+  if (m < k) k = m;
+  if (y < k) k = y;
+  
+  map[0] = c - k;
+  map[1] = m - k;
+  map[2] = y - k;
+
+  gimp_rgb_to_hsv4(map, &h, &z, &v);
+
+  return v;
+}
 
 static void
-indexed_Color_Enhance (gint32 image_ID)  /* a.d.m. */
+enhance_it (const guchar *src, guchar *dest, gdouble vlo, gdouble vhi)
+{
+  gdouble h, z, v;
+  gint c, m, y;
+  gint k;
+  guchar map[3];
+  
+  c = 255 - src[0];
+  m = 255 - src[1];
+  y = 255 - src[2];
+      
+  k = c;
+  if (m < k) k = m;
+  if (y < k) k = y;
+  
+  map[0] = c - k;
+  map[1] = m - k;
+  map[2] = y - k;
+
+  gimp_rgb_to_hsv4(map, &h, &z, &v);
+
+  if (vhi != vlo)
+    v = (v - vlo) / (vhi - vlo);
+
+  gimp_hsv_to_rgb4(map, h, z, v);
+  
+  c = map[0];
+  m = map[1];
+  y = map[2];
+
+  c += k;
+  if (c > 255) c = 255;
+  m += k;
+  if (m > 255) m = 255;
+  y += k;
+  if (y > 255) y = 255;
+
+  dest[0] = 255 - c;
+  dest[1] = 255 - m;
+  dest[2] = 255 - y;
+}
+
+static void
+indexed_Color_Enhance (gint32 image_ID)
 {
   guchar *cmap;
   gint ncols,i;
-
   gdouble vhi = 0.0, vlo = 1.0;
 
   cmap = gimp_image_get_cmap (image_ID, &ncols);
 
-  if (cmap==NULL)
+  if (!cmap)
     {
       printf("Color_Enhance: cmap was NULL!  Quitting...\n");
       gimp_quit();
     }
 
-  for (i=0;i<ncols;i++)
+  for (i = 0; i < ncols; i++)
     {
-      gdouble h, s, v;
+      gdouble v = get_v (&cmap[3 * i]);
-      gint c, m, y;
+
-      gint k;
-      guchar map[3];
-      
-      c = 255 - cmap[i*3+0];
-      m = 255 - cmap[i*3+1];
-      y = 255 - cmap[i*3+2];
-      k = c;
-      if (m < k) k = m;
-      if (y < k) k = y;
-      map[0] = c - k;
-      map[1] = m - k;
-      map[2] = y - k;
-      gimp_rgb_to_hsv4(map, &h, &s, &v);
       if (v > vhi) vhi = v;
       if (v < vlo) vlo = v;
     }
 
-  for (i=0;i<ncols;i++)
+  for (i = 0; i < ncols; i++)
     {
-      gdouble h, s, v;
+      enhance_it (&cmap[3 * i], &cmap[3 * i], vlo, vhi);
-      gint c, m, y;
-      gint k;
-      guchar map[3];
-      
-      c = 255 - cmap[i*3+0];
-      m = 255 - cmap[i*3+1];
-      y = 255 - cmap[i*3+2];
-      k = c;
-      if (m < k) k = m;
-      if (y < k) k = y;
-      map[0] = c - k;
-      map[1] = m - k;
-      map[2] = y - k;
-      gimp_rgb_to_hsv4(map, &h, &s, &v);
-      if (vhi!=vlo)
-	v = (v-vlo) / (vhi-vlo);
-      gimp_hsv_to_rgb4(map, h, s, v);
-      c = map[0];
-      m = map[1];
-      y = map[2];
-      c += k;
-      if (c > 255) c = 255;
-      m += k;
-      if (m > 255) m = 255;
-      y += k;
-      if (y > 255) y = 255;
-      cmap[i*3+0] = 255 - c;
-      cmap[i*3+1] = 255 - m;
-      cmap[i*3+2] = 255 - y;
     }
 
   gimp_image_set_cmap (image_ID, cmap, ncols);
 }
 
+typedef struct {
+  gdouble vhi;
+  gdouble vlo;
+  gboolean has_alpha;
+} ColorEnhanceParam_t;
+
+static void 
+find_vhi_vlo (guchar *src, gint bpp, gpointer data)
+{
+  ColorEnhanceParam_t *param = (ColorEnhanceParam_t*) data;
+
+  if (!param->has_alpha || src[3])
+    {
+      gdouble v = get_v (src);
+
+      if (v > param->vhi) param->vhi = v;
+      if (v < param->vlo) param->vlo = v;
+    }
+}
+
+static void 
+color_enhance_func (guchar *src, guchar *dest, gint bpp, gpointer data)
+{
+  ColorEnhanceParam_t *param = (ColorEnhanceParam_t*) data;
+
+  enhance_it (src, dest, param->vlo, param->vhi);
+
+  if (param->has_alpha)
+    dest[3] = src[3];
+}
 
 static void
 Color_Enhance (GimpDrawable *drawable)
 {
-  GimpPixelRgn src_rgn, dest_rgn;
+  ColorEnhanceParam_t param;
-  guchar *src, *s;
-  guchar *dest, *d;
-  gdouble  vhi = 0.0, vlo = 1.0;
-  gint    progress, max_progress;
-  gint    has_alpha, alpha;
-  gint    x1, y1, x2, y2;
-  gint    x, y;
-  gpointer pr;
 
-  /* Get selection area */
+  param.has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
-  gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
+  param.vhi = 0.0;
-  has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
+  param.vlo = 1.0;
-  alpha = (has_alpha) ? drawable->bpp - 1 : drawable->bpp;
 
-  /* Initialize progress */
+  gimp_rgn_iterate1 (drawable, run_mode, find_vhi_vlo, &param);
-  progress = 0;
+  gimp_rgn_iterate2 (drawable, run_mode, color_enhance_func, &param);
-  max_progress = (x2 - x1) * (y2 - y1) * 2;
-
-  gimp_pixel_rgn_init (&src_rgn, drawable,
-		       x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE);
-
-  for (pr = gimp_pixel_rgns_register (1, &src_rgn);
-       pr != NULL;
-       pr = gimp_pixel_rgns_process (pr))
-    {
-      src = src_rgn.data;
-
-      for (y = 0; y < src_rgn.h; y++)
-	{
-	  s = src;
-	  for (x = 0; x < src_rgn.w; x++)
-	    {
-	      if (!has_alpha || (has_alpha && s[alpha])) 
-		{
-		  gdouble h, z, v;
-		  gint c, m, y;
-		  gint k;
-		  guchar map[3];
-		  
-		  c = 255 - s[0];
-		  m = 255 - s[1];
-		  y = 255 - s[2];
-		  k = c;
-		  if (m < k) k = m;
-		  if (y < k) k = y;
-		  map[0] = c - k;
-		  map[1] = m - k;
-		  map[2] = y - k;
-		  gimp_rgb_to_hsv4(map, &h, &z, &v);
-		  if (v > vhi) vhi = v;
-		  if (v < vlo) vlo = v;
-		}
-
-	      s += src_rgn.bpp;
-	    }
-
-	  src += src_rgn.rowstride;
-	}
-
-      /* Update progress */
-      progress += src_rgn.w * src_rgn.h;
-
-      gimp_progress_update ((gdouble) progress / (gdouble) max_progress);
-    }
-
-  /* Now substitute pixel vales */
-  gimp_pixel_rgn_init (&src_rgn, drawable,
-		       x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE);
-  gimp_pixel_rgn_init (&dest_rgn, drawable,
-		       x1, y1, (x2 - x1), (y2 - y1), TRUE, TRUE);
-
-  for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
-       pr != NULL;
-       pr = gimp_pixel_rgns_process (pr))
-    {
-      src = src_rgn.data;
-      dest = dest_rgn.data;
-
-      for (y = 0; y < src_rgn.h; y++)
-	{
-	  s = src;
-	  d = dest;
-
-	  for (x = 0; x < src_rgn.w; x++)
-	    {
-	      gdouble h, z, v;
-	      gint c, m, y;
-	      gint k;
-	      guchar map[3];
-	      
-	      c = 255 - s[0];
-	      m = 255 - s[1];
-	      y = 255 - s[2];
-	      k = c;
-	      if (m < k) k = m;
-	      if (y < k) k = y;
-	      map[0] = c - k;
-	      map[1] = m - k;
-	      map[2] = y - k;
-	      gimp_rgb_to_hsv4(map, &h, &z, &v);
-	      if (vhi!=vlo)
-		v = (v-vlo) / (vhi-vlo);
-	      gimp_hsv_to_rgb4(map, h, z, v);
-	      c = map[0];
-	      m = map[1];
-	      y = map[2];
-	      c += k;
-	      if (c > 255) c = 255;
-	      m += k;
-	      if (m > 255) m = 255;
-	      y += k;
-	      if (y > 255) y = 255;
-	      d[0] = 255 - c;
-	      d[1] = 255 - m;
-	      d[2] = 255 - y;
-
-	      if (has_alpha)
-		d[alpha] = s[alpha];
-
-	      s += src_rgn.bpp;
-	      d += dest_rgn.bpp;
-	    }
-
-	  src += src_rgn.rowstride;
-	  dest += dest_rgn.rowstride;
-
-	}
-
-      /* Update progress */
-      progress += src_rgn.w * src_rgn.h;
-
-      gimp_progress_update ((gdouble) progress / (gdouble) max_progress);
-    }
-
-  /*  update the region  */
-  gimp_drawable_flush (drawable);
-  gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
-  gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
 }
+

plug-ins/common/cubism.c

@@ -69,7 +69,6 @@ static void      run    (gchar         *name,
 			 GimpParam    **return_vals);
 static void      cubism (GimpDrawable  *drawable);
 
-static void      render_cubism        (GimpDrawable *drawable);
 static void      fill_poly_color      (Polygon      *poly,
 				       GimpDrawable *drawable,
 				       guchar       *col);
@@ -109,8 +108,6 @@ static void      cubism_ok_callback   (GtkWidget *widget,
  *  Local variables
  */
 
-static guchar bg_col[4];
-
 static CubismVals cvals =
 {
   10.0,        /* tile_size */
@@ -253,52 +250,6 @@ run (gchar      *name,
   gimp_drawable_detach (active_drawable);
 }
 
-static void
-cubism (GimpDrawable *drawable)
-{
-  GimpRGB background;
-  gint    x1, y1, x2, y2;
-
-  /*  find the drawable mask bounds  */
-  gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
-
-  /*  determine the background color  */
-  if (cvals.bg_color == BLACK)
-    {
-      bg_col[0] = bg_col[1] = bg_col[2] = bg_col[3] = 0;
-    }
-  else
-    {
-      gimp_palette_get_background (&background);
-      switch (gimp_drawable_type (drawable->drawable_id))
-	{
-	case GIMP_RGBA_IMAGE:
-	  bg_col[3] = 0;
-	case GIMP_RGB_IMAGE:
-	  gimp_rgb_get_uchar (&background, 
-			      &bg_col[0], &bg_col[1], &bg_col[2]);
-	  break;
-	case GIMP_GRAYA_IMAGE:
-	  bg_col[1] = 0;
-	case GIMP_GRAY_IMAGE:
-	  bg_col[0] = gimp_rgb_intensity_uchar (&background);
-
-	default:
-	  break;
-	}
-    }
-
-  gimp_progress_init (_("Cubistic Transformation"));
-
-  /*  render the cubism  */
-  render_cubism (drawable);
-
-  /*  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));
-}
-
 static gint
 cubism_dialog (void)
 {
@@ -391,10 +342,10 @@ cubism_ok_callback (GtkWidget *widget,
 }
 
 static void
-render_cubism (GimpDrawable *drawable)
+cubism (GimpDrawable *drawable)
 {
   GimpPixelRgn src_rgn;
-  gdouble img_area, tile_area;
+  guchar bg_col[4];
   gdouble x, y;
   gdouble width, height;
   gdouble theta;
@@ -416,8 +367,18 @@ render_cubism (GimpDrawable *drawable)
   has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
   bytes = drawable->bpp;
   gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
-  img_area = (x2 - x1) * (y2 - y1);
+
-  tile_area = SQR (cvals.tile_size);
+  /*  determine the background color  */
+  if (cvals.bg_color == BLACK)
+    {
+      bg_col[0] = bg_col[1] = bg_col[2] = bg_col[3] = 0;
+    }
+  else
+    {
+      gimp_get_bg_guchar (drawable, TRUE, bg_col);
+    }
+
+  gimp_progress_init (_("Cubistic Transformation"));
 
   cols = ((x2 - x1) + cvals.tile_size - 1) / cvals.tile_size;
   rows = ((y2 - y1) + cvals.tile_size - 1) / cvals.tile_size;
@@ -446,7 +407,7 @@ render_cubism (GimpDrawable *drawable)
 
   count = 0;
   gimp_pixel_rgn_init (&src_rgn, drawable,
-		       x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE);
+		       x1, y1, x2 - x1, y2 - y1, FALSE, FALSE);
 
   while (count < num_tiles)
     {
@@ -456,10 +417,12 @@ render_cubism (GimpDrawable *drawable)
 	- g_rand_double_range (gr, 0, cvals.tile_size/2.0) + x1;
       y = i * cvals.tile_size + (cvals.tile_size / 4.0) 
 	- g_rand_double_range (gr, 0, cvals.tile_size/2.0) + y1;
-      width = (cvals.tile_size + g_rand_double_range (gr, 0, cvals.tile_size / 4.0) 
+      width = (cvals.tile_size + 
-	       - cvals.tile_size / 8.0) * cvals.tile_saturation;
+	       g_rand_double_range (gr, 0, cvals.tile_size / 4.0) -
-      height = (cvals.tile_size + g_rand_double_range (gr, 0, cvals.tile_size / 4.0) 
+	       cvals.tile_size / 8.0) * cvals.tile_saturation;
-		- cvals.tile_size / 8.0) * cvals.tile_saturation;
+      height = (cvals.tile_size + 
+		g_rand_double_range (gr, 0, cvals.tile_size / 4.0) - 
+		cvals.tile_size / 8.0) * cvals.tile_saturation;
       theta = g_rand_double_range (gr, 0, 2 * G_PI);
       polygon_reset (&poly);
       polygon_add_point (&poly, -width / 2.0, -height / 2.0);
@@ -470,20 +433,12 @@ render_cubism (GimpDrawable *drawable)
       polygon_translate (&poly, x, y);
 
       /*  bounds check on x, y  */
-      ix = (int) x;
+      ix = CLAMP (x, x1, x2 - 1);
-      iy = (int) y;
+      iy = CLAMP (y, y1, y2 - 1);
-      if (ix < x1)
-	ix = x1;
-      if (ix >= x2)
-	ix = x2 - 1;
-      if (iy < y1)
-	iy = y1;
-      if (iy >= y2)
-	iy = y2 - 1;
 
       gimp_pixel_rgn_get_pixel (&src_rgn, col, ix, iy);
 
-      if (! has_alpha || (has_alpha && col[bytes - 1] != 0))
+      if (!has_alpha || col[bytes - 1])
 	fill_poly_color (&poly, drawable, col);
 
       count++;
@@ -494,6 +449,11 @@ render_cubism (GimpDrawable *drawable)
   gimp_progress_update (1.0);
   g_free (random_indices);
   g_rand_free (gr);
+
+  /*  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);
 }
 
 static inline gdouble
@@ -659,7 +619,6 @@ fill_poly_color (Polygon   *poly,
 			{
 			  xx = (gdouble) j / (gdouble) SUPERSAMPLE + min_x;
 			  alpha = (gint) (val * calc_alpha_blend (vec, one_over_dist, xx - sx, yy - sy));
-
 			  gimp_pixel_rgn_get_pixel (&src_rgn, buf, x, y);
 
 #ifndef USE_READABLE_BUT_SLOW_CODE

plug-ins/common/edge.c

@@ -44,6 +44,7 @@
 
 #include "config.h"
 
+#include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -88,8 +89,6 @@ static void      run    (gchar      *name,
 static void      edge        (GimpDrawable *drawable);
 static gint      edge_dialog (GimpDrawable *drawable);
 
-static long      long_sqrt   (long n);
-
 /***** Local vars *****/
 
 GimpPlugInInfo PLUG_IN_INFO =
@@ -232,94 +231,6 @@ run (gchar      *name,
   gimp_drawable_detach (drawable);
 }
 
-/**********************************************************************
-   TileBuf Util Routines End
- **********************************************************************/
-
-static long
-long_sqrt (long n)
-{
-#define lsqrt_max4pow (1UL << 30)
-  /* lsqrt_max4pow is the (machine-specific) largest power of 4 that can
-   * be represented in an unsigned long.
-   *
-   * Compute the integer square root of the integer argument n
-   * Method is to divide n by x computing the quotient x and remainder r
-   * Notice that the divisor x is changing as the quotient x changes
-   * 
-   * Instead of shifting the dividend/remainder left, we shift the
-   * quotient/divisor right. The binary point starts at the extreme
-   * left, and shifts two bits at a time to the extreme right.
-   * 
-   * The residue contains n-x^2. (Within these comments, the ^ operator
-   * signifies exponentiation rather than exclusive or. Also, the /
-   * operator returns fractions, rather than truncating, so 1/4 means
-   * one fourth, not zero.)
-   * 
-   * Since (x + 1/2)^2 == x^2 + x + 1/4,
-   * n - (x + 1/2)^2 == (n - x^2) - (x + 1/4)
-   * Thus, we can increase x by 1/2 if we decrease (n-x^2) by (x+1/4)
-   */
-
-  gulong residue;        /* n - x^2  */
-  gulong root;           /* x + 1/4  */
-  gulong half;           /* 1/2      */
-
-  residue = n;           /* n - (x = 0)^2, with suitable alignment */
-
-  /*
-   * if the correct answer fits in two bits, pull it out of a magic hat
-   */
-  if (residue <= 12)
-    return (0x03FFEA94 >> (residue *= 2)) & 3;
-
-  root = lsqrt_max4pow;         /* x + 1/4, shifted all the way left */
-  /* half = root + root; 1/2, shifted likewise */
-
-  /* 
-   * Unwind iterations corresponding to leading zero bits 
-   */
-  while (root > residue)
-    root >>= 2;
-
-  /*
-   * Unwind the iteration corresponding to the first one bit
-   * Operations have been rearranged and combined for efficiency
-   * Initialization of half is folded into this iteration
-   */
-  residue -= root;              /* Decrease (n-x^2) by (0+1/4)             */
-  half = root >> 2;             /* 1/4, with binary point shifted right 2  */
-  root += half;                 /* x=1. (root is now (x=1)+1/4.)           */
-  half += half;                 /* 1/2, properly aligned                   */
-
-  /*
-   * Normal loop (there is at least one iteration remaining)
-   */
-  do
-    {
-      if (root <= residue)      /* Whenever we can,                          */
-        {
-          residue -= root;      /* decrease (n-x^2) by (x+1/4)               */
-          root += half;         /* increase x by 1/2                         */
-        }
-      half >>= 2;               /* Shift binary point 2 places right          */
-      root -= half;             /* x{ +1/2 } +1/4 - 1/8 == x { +1/2 } 1/8     */
-      root >>= 1;               /* 2x{ +1 } +1/4, shifted right 2 places      */
-    }
-  while (half);                 /* When 1/2 == 0, bin. point is at far right  */
-
-  /* 
-   * round up if (x+1/2)^2 < n
-   */
-  if (root < residue)
-    ++root;
-
-  /* 
-   * Guaranteed to be correctly rounded (or truncated)
-   */
-  return root;
-}
-
 /********************************************************/
 /*              Edge Detection main                     */
 /********************************************************/
@@ -421,7 +332,8 @@ edge (GimpDrawable *drawable)
 			     (PIX(2,2) - PIX(2,0));
 #undef  PIX
 		      /* common job ... */
-		      sum = long_sqrt ((long) sum1 * sum1 + (long) sum2 * sum2);
+		      sum = (glong) (sqrt((long) sum1 * sum1 + 
+					  (long) sum2 * sum2) + 0.5);
 		      sum = (sum * scale) >> 16;    /* arbitrary scaling factor */
 		      if (sum > maxval)
 			sum = maxval;
@@ -458,7 +370,8 @@ edge (GimpDrawable *drawable)
 			 2 * (pix12[chan] - pix10[chan]) +
 			     (pix22[chan] - pix20[chan]);
 		      /* common job ... */
-		      sum = long_sqrt ((long) sum1 * sum1 + (long) sum2 * sum2);
+		      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;

plug-ins/common/gradmap.c

@@ -53,9 +53,6 @@
 
 #include "config.h"
 
-#include <stdio.h>
-#include <stdlib.h>
-
 #include <libgimp/gimp.h>
 
 #include "libgimp/stdplugins-intl.h"
@@ -71,6 +68,8 @@ static char rcsid[] = "$Id$";
 #define TILE_CACHE_SIZE 32
 #define LUMINOSITY(X)	(INTENSITY (X[0], X[1], X[2]))
 
+static GimpRunMode run_mode;
+
 /* Declare a local function.
  */
 static void	 query		(void);
@@ -135,7 +134,6 @@ run (gchar   *name,
 {
   static GimpParam values[1];
   GimpDrawable *drawable;
-  GimpRunMode run_mode;
   GimpPDBStatusType status = GIMP_PDB_SUCCESS;
 
   run_mode = param[0].data.d_int32;
@@ -174,86 +172,46 @@ run (gchar   *name,
   gimp_drawable_detach (drawable);
 }
 
+typedef struct {
+  guchar *samples;
+  gboolean is_rgb;
+  gboolean has_alpha;
+} GradMapParam_t;
+
+static void 
+gradmap_func (guchar *src, guchar *dest, gint bpp, gpointer data)
+{
+  GradMapParam_t *param = (GradMapParam_t*) data;
+  gint lum;
+  gint b;
+  guchar *samp;
+
+  lum = (param->is_rgb) ? LUMINOSITY (src) : src[0];
+  samp = &param->samples[lum * bpp];
+
+  if (param->has_alpha)
+    {
+      for (b = 0; b < bpp - 1; b++)
+	dest[b] = samp[b];
+      dest[b] = ((guint)samp[b] * (guint)src[b]) / 255;
+    }
+  else
+    {
+      for (b = 0; b < bpp; b++)
+	dest[b] = samp[b];
+    }
+}
+
 static void
 gradmap (GimpDrawable *drawable)
 {
-  GimpPixelRgn	src_rgn, dest_rgn;
+  GradMapParam_t param;
-  gpointer	pr;
-  guchar	*src_row, *dest_row;
-  guchar	*src, *dest;
-  gint		progress, max_progress;
-  gint		x1, y1, x2, y2;
-  gint		row, col;
-  gint		bpp, color, has_alpha;
-  guchar	*samples, *samp;
-  gint		lum;				/* luminosity */
-  gint		b;
 
-  gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
+  param.is_rgb = gimp_drawable_is_rgb (drawable->drawable_id);
+  param.has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
+  param.samples = get_samples (drawable);
 
-  bpp = gimp_drawable_bpp (drawable->drawable_id);
+  gimp_rgn_iterate2 (drawable, run_mode, gradmap_func, &param);
-  color = gimp_drawable_is_rgb (drawable->drawable_id);
-  has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
-
-  samples = get_samples (drawable);
-
-  gimp_pixel_rgn_init (&src_rgn, drawable, x1, y1, x2-x1, y2-y1, FALSE, FALSE);
-  gimp_pixel_rgn_init (&dest_rgn, drawable, x1, y1, x2-x1, y2-y1, TRUE, TRUE);
-
-  /* Initialize progress */
-  progress = 0;
-  max_progress = (x2 - x1) * (y2 - y1);
-
-  for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
-       pr != NULL; pr = gimp_pixel_rgns_process (pr))
-    {
-      src_row = src_rgn.data;
-      dest_row = dest_rgn.data;
-
-      for (row = 0; row < src_rgn.h; row++)
-	{
-	  src = src_row;
-	  dest = dest_row;
-
-	  for (col = 0; col < src_rgn.w; col++)
-	    {
-	      if (color)
-		{
-		  lum = LUMINOSITY (src);
-		  lum = CLAMP (lum, 0, 255);	/* to make sure */
-		}
-	      else
-		lum = src[0];
-
-	      samp = &samples[lum * bpp];
-	      if (has_alpha)
-		{
-		  for (b = 0; b < bpp - 1; b++)
-		    dest[b] = samp[b];
-		  dest[b] = ((guint)(samp[b]) * (guint)(src[b])) / 255;
-		}
-	      else
-		{
-		  for (b = 0; b < bpp; b++)
-		    dest[b] = samp[b];
-		}
-
-	      src += src_rgn.bpp;
-	      dest += dest_rgn.bpp;
-	    }
-	  src_row += src_rgn.rowstride;
-	  dest_row += dest_rgn.rowstride;
-	}
-      /* Update progress */
-      progress += src_rgn.w * src_rgn.h;
-      gimp_progress_update ((double) progress / (double) max_progress);
-    }
-
-  g_free (samples);
-
-  gimp_drawable_flush (drawable);
-  gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
-  gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
 }
 
 /*

plug-ins/common/max_rgb.c

@@ -29,7 +29,6 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 
 #include <gtk/gtk.h>
 
@@ -51,8 +50,8 @@ static void	run	(gchar      *name,
 			 gint       *nreturn_vals,
 			 GimpParam **return_vals);
 
-static GimpPDBStatusType main_function     (GimpDrawable *drawable, 
+static void main_function (GimpDrawable *drawable, 
-					    gboolean      preview_mode);
+			   gboolean      preview_mode);
 
 static gint	   dialog         (GimpDrawable *drawable);
 static void        ok_callback    (GtkWidget    *widget,
@@ -95,6 +94,7 @@ static Interface interface =
   FALSE
 };
 
+static GimpRunMode       run_mode;
 static GimpFixMePreview *preview;
 
 MAIN ()
@@ -136,7 +136,6 @@ run (gchar      *name,
   GimpDrawable      *drawable;
   static GimpParam   values[1];
   GimpPDBStatusType  status = GIMP_PDB_EXECUTION_ERROR;
-  GimpRunMode        run_mode;
   
   run_mode = param[0].data.d_int32;
   drawable = gimp_drawable_get (param[2].data.d_drawable);
@@ -171,7 +170,7 @@ run (gchar      *name,
       break;
     }
   
-  status = main_function (drawable, FALSE);
+  main_function (drawable, FALSE);
 
   if (run_mode != GIMP_RUN_NONINTERACTIVE)
     gimp_displays_flush ();
@@ -181,137 +180,81 @@ run (gchar      *name,
   values[0].data.d_status = status;
 }
 
-static GimpPDBStatusType
+typedef struct {
+  gint init_value;
+  gint flag;
+  gboolean has_alpha;
+} MaxRgbParam_t;
+
+static void
+max_rgb_func (guchar *src, guchar *dest, gint bpp, gpointer data)
+{
+  MaxRgbParam_t *param = (MaxRgbParam_t*) data;
+  gint   ch, max_ch = 0;
+  guchar max, tmp_value;
+  
+  max = param->init_value;
+  for (ch = 0; ch < 3; ch++)
+    if (param->flag * max <= param->flag * (tmp_value = (*src++)))
+      {
+	if (max == tmp_value)
+	  {
+	    max_ch += 1 << ch;
+	  }
+	else
+	  {
+	    max_ch = 1 << ch; /* clear memories of old channels */
+	    max = tmp_value;
+	  }
+      }
+
+  dest[0] = (max_ch & (1 << 0)) ? max : 0;
+  dest[1] = (max_ch & (1 << 1)) ? max : 0;
+  dest[2] = (max_ch & (1 << 2)) ? max : 0;
+  if (param->has_alpha)
+    dest[3] = src[3];
+}
+
+static void
 main_function (GimpDrawable *drawable, 
 	       gboolean      preview_mode)
 {
-  GimpPixelRgn  src_rgn, dest_rgn;
+  MaxRgbParam_t param;
-  guchar    *src, *dest, *save_dest, *src_data, *dest_data;
-  gpointer   pr = NULL;
-  gint       x, y, x1, x2, y1, y2;
-  gint       gap, total, processed = 0;
-  gint       init_value, flag;
-  gint       bpp = 3;
-
-  init_value = (pvals.max_p > 0) ? 0 : 255;
-  flag = (0 < pvals.max_p) ? 1 : -1;
-
-  if (preview_mode) 
-    {
-      x1 = y1 = 0;
-      x2 = preview->width;
-      y2 = preview->height;
-      gap = 0; /* no alpha on preview */
-      bpp = preview->bpp;
-    } 
-  else 
-    {
-      gap = (gimp_drawable_has_alpha (drawable->drawable_id)) ? 1 : 0;
-      gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
-      gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
-      gimp_pixel_rgn_init (&src_rgn, drawable,
-			   x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE);
-      gimp_pixel_rgn_init (&dest_rgn, drawable,
-			   x1, y1, (x2 - x1), (y2 - y1), TRUE, TRUE);
-      pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
-      gimp_progress_init ( _("Max RGB: Scanning..."));
-    }
   
-  total = (x2 - x1) * (y2 - y1);
+  param.init_value = (pvals.max_p > 0) ? 0 : 255;
-  if (total < 1)
+  param.flag = (0 < pvals.max_p) ? 1 : -1;
-    return GIMP_PDB_EXECUTION_ERROR;
 
   if (preview_mode) 
     {
-      src_data = g_malloc (preview->rowstride * y2);
+      gint x, y;
-      memcpy (src_data, preview->cache, preview->rowstride * y2);
+      gint bpp = preview->bpp;
-      dest_data = g_malloc (preview->rowstride * y2);
+
-      save_dest = dest_data;
+      param.has_alpha = FALSE; /* no alpha on preview */
-      
+
-      for (y = 0; y < y2; y++)
+      for (y = 0; y < preview->height; y++)
 	{
-	  src  = src_data  + y * preview->rowstride;
+	  guchar *src = preview->cache + y * preview->rowstride;
-	  dest = dest_data + y * preview->rowstride;
+	  guchar *dest = preview->buffer + y * preview->rowstride;
-	  
+
-	  for (x = 0; x < x2; x++)
+	  for (x = 0; x < preview->width; x++)
 	    {
-	      gint   ch, max_ch = 0;
+	      max_rgb_func (src, dest, bpp, &param);
-	      guchar max, tmp_value;
+	      dest += bpp;
-	      
+	      src += bpp;
-	      max = init_value;
-	      for (ch = 0; ch < 3; ch++)
-		if (flag * max <= flag * (tmp_value = (*src++)))
-		  {
-		    if (max == tmp_value)
-		      {
-			max_ch += 1 << ch;
-		      }
-		    else
-		      {
-			max_ch = 1 << ch; /* clear memories of old channels */
-			max = tmp_value;
-		      }
-		  }
-	      
-	      for ( ch = 0; ch < 3; ch++)
-		*dest++ = (guchar)(((max_ch & (1 << ch)) > 0) ? max : 0);
-	      
-	      if (gap) 
-		*dest++ = *src++;
 	    }
 	}
-      
-      memcpy (preview->buffer, save_dest, preview->rowstride * y2);
       gtk_widget_queue_draw (preview->widget);
     } 
   else 
     { /* normal mode */
-      for (; pr != NULL; pr = gimp_pixel_rgns_process (pr))
+      param.has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
-	{
+
-	  for (y = 0; y < src_rgn.h; y++)
+      gimp_progress_init ( _("Max RGB: Scanning..."));
-	    {
+
-	      src = src_rgn.data + y * src_rgn.rowstride;
+      gimp_rgn_iterate2 (drawable, run_mode, max_rgb_func, &param);
-	      dest = dest_rgn.data + y * dest_rgn.rowstride;
+
-	      
-	      for (x = 0; x < src_rgn.w; x++)
-		{
-		  gint   ch, max_ch = 0;
-		  guchar max, tmp_value;
-		  
-		  max = init_value;
-		  for (ch = 0; ch < 3; ch++)
-		    if (flag * max <= flag * (tmp_value = (*src++)))
-		      {
-			if (max == tmp_value)
-			  {
-			    max_ch += 1 << ch;
-			  }
-			else
-			  {
-			    max_ch = 1 << ch; /* clear memories of old channels */
-			    max = tmp_value;
-			  }
-			
-		      }
-		  for ( ch = 0; ch < 3; ch++)
-		    *dest++ = (guchar)(((max_ch & (1 << ch)) > 0) ? max : 0);
-		  
-		  if (gap) 
-		    *dest++=*src++;
-		  
-		  if ((++processed % (total / PROGRESS_UPDATE_NUM + 1)) == 0)
-		    gimp_progress_update ((gdouble) processed / (gdouble) total); 
-		}
-	    }
-	}
-      gimp_progress_update (1.0);
-      gimp_drawable_flush (drawable);
-      gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
-      gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
       gimp_drawable_detach (drawable);
-    }
+    }  
-  
-  return GIMP_PDB_SUCCESS;
 }
  
 

plug-ins/common/normalize.c

@@ -58,6 +58,8 @@ GimpPlugInInfo PLUG_IN_INFO =
   run,   /* run_proc   */
 };
 
+static GimpRunMode run_mode;
+
 
 MAIN ()
 
@@ -101,7 +103,6 @@ run (gchar      *name,
 {
   static GimpParam   values[1];
   GimpDrawable      *drawable;
-  GimpRunMode    run_mode;
   GimpPDBStatusType  status = GIMP_PDB_SUCCESS;
 
   gint32 image_ID;
@@ -182,126 +183,69 @@ indexed_normalize (gint32 image_ID)  /* a.d.m. */
   gimp_image_set_cmap (image_ID, cmap, ncols);
 }
 
+typedef struct {
+  guchar  lut[256];
+  gdouble min;
+  gdouble max;
+  gint alpha;
+  gboolean has_alpha;
+} NormalizeParam_t;
+
+static void 
+find_min_max (guchar *src, gint bpp, gpointer data)
+{
+  NormalizeParam_t *param = (NormalizeParam_t*) data;
+  gint b;
+
+  for (b = 0; b < param->alpha; b++)
+    {
+      if (!param->has_alpha || src[param->alpha])
+	{
+	  if (src[b] < param->min)
+	    param->min = src[b];
+	  if (src[b] > param->max)
+	    param->max = src[b];
+	}
+    }
+}
+
+static void 
+normalize_func (guchar *src, guchar *dest, gint bpp, gpointer data)
+{
+  NormalizeParam_t *param = (NormalizeParam_t*) data;
+  gint b;
+
+  for (b = 0; b < param->alpha; b++)
+    dest[b] = param->lut[src[b]];
+  
+  if (param->has_alpha)
+    dest[param->alpha] = src[param->alpha];
+}
 
 static void
 normalize (GimpDrawable *drawable)
 {
-  GimpPixelRgn src_rgn, dest_rgn;
+  NormalizeParam_t param;
-  guchar *src, *s;
+  gint x;
-  guchar *dest, *d;
-  guchar  min, max;
   guchar  range;
-  guchar  lut[256];
-  gint    progress, max_progress;
-  gint    has_alpha, alpha;
-  gint    x1, y1, x2, y2;
-  gint    x, y, b;
-  gpointer pr;
 
-  /* Get selection area */
+  param.min = 255;
-  gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
+  param.max = 0;
-  has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
+  param.has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
-  alpha = (has_alpha) ? drawable->bpp - 1 : drawable->bpp;
+  param.alpha = (param.has_alpha) ? drawable->bpp - 1 : drawable->bpp;
 
-  /* Initialize progress */
+  gimp_rgn_iterate1 (drawable, run_mode, find_min_max, &param);
-  progress = 0;
-  max_progress = (x2 - x1) * (y2 - y1) * 2;
-
-  /* Get minimum and maximum values for each channel */
-  min = 255;
-  max = 0;
-
-  gimp_pixel_rgn_init (&src_rgn, drawable,
-		       x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE);
-
-  for (pr = gimp_pixel_rgns_register (1, &src_rgn);
-       pr != NULL;
-       pr = gimp_pixel_rgns_process (pr))
-    {
-      src = src_rgn.data;
-
-      for (y = 0; y < src_rgn.h; y++)
-	{
-	  s = src;
-	  for (x = 0; x < src_rgn.w; x++)
-	    {
-	      for (b = 0; b < alpha; b++)
-		{
-		  if (!has_alpha || (has_alpha && s[alpha]))
-		    {
-		      if (s[b] < min)
-			min = s[b];
-		      if (s[b] > max)
-			max = s[b];
-		    }
-		}
-
-	      s += src_rgn.bpp;
-	    }
-
-	  src += src_rgn.rowstride;
-	}
-
-      /* Update progress */
-      progress += src_rgn.w * src_rgn.h;
-
-      gimp_progress_update ((double) progress / (double) max_progress);
-    }
 
   /* Calculate LUT */
 
-  range = max - min;
+  range = param.max - param.min;
 
   if (range != 0)
-    for (x = min; x <= max; x++)
+    for (x = param.min; x <= param.max; x++)
-      lut[x] = 255 * (x - min) / range;
+      param.lut[x] = 255 * (x - param.min) / range;
   else
-    lut[min] = min;
+    param.lut[(gint)param.min] = param.min;
 
-
+  gimp_rgn_iterate2 (drawable, run_mode, normalize_func, &param);
-  /* Now substitute pixel vales */
-  gimp_pixel_rgn_init (&src_rgn, drawable,
-		       x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE);
-  gimp_pixel_rgn_init (&dest_rgn, drawable,
-		       x1, y1, (x2 - x1), (y2 - y1), TRUE, TRUE);
-
-  for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
-       pr != NULL;
-       pr = gimp_pixel_rgns_process (pr))
-    {
-      src = src_rgn.data;
-      dest = dest_rgn.data;
-
-      for (y = 0; y < src_rgn.h; y++)
-	{
-	  s = src;
-	  d = dest;
-
-	  for (x = 0; x < src_rgn.w; x++)
-	    {
-	      for (b = 0; b < alpha; b++)
-		d[b] = lut[s[b]];
-
-	      if (has_alpha)
-		d[alpha] = s[alpha];
-
-	      s += src_rgn.bpp;
-	      d += dest_rgn.bpp;
-	    }
-
-	  src += src_rgn.rowstride;
-	  dest += dest_rgn.rowstride;
-
-	}
-
-      /* Update progress */
-      progress += src_rgn.w * src_rgn.h;
-
-      gimp_progress_update ((double) progress / (double) max_progress);
-    }
-
-  /*  update the region  */
-  gimp_drawable_flush (drawable);
-  gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
-  gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
 }
+