Improved benchmarking ability and performance for these filters.

11 files changed, 674 insertions, 537 deletions

diff --git a/java/ImageProcessing/filters/BlurFilter.java b/java/ImageProcessing/filters/BlurFilter.java
index 95937d52f93..e071324e491 100644
--- a/java/ImageProcessing/filters/BlurFilter.java
+++ b/java/ImageProcessing/filters/BlurFilter.java
@@ -25,56 +25,66 @@ public class BlurFilter extends SpatialFilter
 	return;
       }
 
-    int[] pixels = new int[columns_];
+    System.gc();
+    
+    int[] pixels = new int[columns_*rows_];
     int pixel = 0, count = 0;
-    int red, green, blue;
+    int red, green, blue, index;
     int alpha, n2 = degree_/2;
 
-    for (int y = 0; y < rows_; y++)
+    profile_timer_.start();
+
+    for (int z = SpatialFilter.iterations_; z-- > 0;)
       {
-	for (int x = 0; x < columns_ - 1; x++)
-	  {	    
-	    red = 0; green = 0; blue = 0; count = 0;
-	    alpha = (raster_[y*columns_ + x] >> 24) & 0xff;
-	    
-	    for (int y1 = y - n2; y1 < y + n2; y1++)
-	      {
-		if (y1 >= 0 && y1 < rows_)
-		  {		
-		    for (int x1 = x - n2; x1 < x + n2; x1++)
-		      {
-			if (x1 >= 0 && x1 < columns_)
+	   
+	for (int y = 0, i = 0; y < rows_; y++)
+	  {
+	    for (int x = 0; x < columns_; x++, i++)
+	      {	    
+		red = 0; green = 0; blue = 0; count = 0;
+		alpha = (raster_[i] >> 24) & 0xff;
+		
+		for (int y1 = y - n2; y1 < y + n2; y1++)
+		  {
+		    index = y1*columns_;
+		    if (y1 >= 0 && y1 < rows_)
+		      {		
+			for (int x1 = x - n2; x1 < x + n2; x1++)
 			  {
-			    pixel = raster_[y1*columns_ + x1];
-			    
-			    red += (pixel >> 16) & 0xff;
-			    green += (pixel >> 8) & 0xff;
-			    blue += (pixel) & 0xff;
-			    count++;
+			    if (x1 >= 0 && x1 < columns_)
+			      {
+				pixel = raster_[index + x1];
+				
+				red += (pixel >> 16) & 0xff;
+				green += (pixel >> 8) & 0xff;
+				blue += (pixel) & 0xff;
+				count++;
+			      }
 			  }
 		      }
 		  }
-	      }
-	    
-	    red /= count;
-	    green /= count;
-	    blue /= count;
-
-	    if (red < 0) red = 0;
-	    if (green < 0) green = 0;
-	    if (blue < 0) blue = 0 ;
-
-	    if (red > 255) red = 255;
-	    if (green > 255) green = 255;
-	    if (blue > 255) blue = 255;
-
-	    pixels[x] = (alpha << 24) | (red << 16) | (green << 8) | blue;
+		
+		red /= count;
+		green /= count;
+		blue /= count;
+		
+		if (red < 0) red = 0;
+		if (green < 0) green = 0;
+		if (blue < 0) blue = 0 ;
+		
+		if (red > 255) red = 255;
+		if (green > 255) green = 255;
+		if (blue > 255) blue = 255;
+		
+		pixels[i] = (alpha << 24) | (red << 16) | (green << 8) | blue;
+	      }       
 	  }
-	
-	consumer.setPixels(0, y, columns_, 1, defaultRGB_, pixels, 0, columns_);
       }
 
+    profile_timer_.stop();
+    
     System.out.println("Finished altering image");
+    consumer.setPixels(0, 0, columns_, rows_, defaultRGB_, pixels, 0, columns_);
     consumer.imageComplete(status);
   }
   
diff --git a/java/ImageProcessing/filters/DeSpeckleFilter.java b/java/ImageProcessing/filters/DeSpeckleFilter.java
index c363bd83338..d9bff1de3b5 100644
--- a/java/ImageProcessing/filters/DeSpeckleFilter.java
+++ b/java/ImageProcessing/filters/DeSpeckleFilter.java
@@ -25,14 +25,18 @@ public class DeSpeckleFilter extends SpatialFilter
     if (status == IMAGEERROR || status == IMAGEABORTED)
       {
 	consumer.imageComplete(status);
-	System.out.println("Image Error: " + status);
+	System.out.println("DeSpeckleFilter Image Error: " + status);
 	return;
       }
 
+    System.gc();
+    
     int rsum, bsum, gsum, r, g, b, a;
-    int count, n2, nsq, c2;
+    int count, n2, nsq, c2, lcv, lcv2, index;
     int[] rtab, gtab, btab;
-    int[] pixels = new int[columns_];
+    int[] pixels = new int[columns_*rows_];
+
+    profile_timer_.start();
     
     n2 = degree_/2;
     nsq = degree_ * degree_;
@@ -41,71 +45,78 @@ public class DeSpeckleFilter extends SpatialFilter
     gtab = new int[nsq];
     btab = new int[nsq];
 
-    for (int y = 0; y < rows_; y++)
-      {		
-	for (int x = 0; x < columns_; x++)
-	  {	    
-	    rsum = gsum = bsum = 0;
-	    count = 0;
-
-	    for (int y1 = y - n2; y1 < y + n2; y1++)
-	      {
-		if (y1 >= 0 && y1 < rows_)
+    for (int z = SpatialFilter.iterations_; z-- > 0;)
+      {    
+	for (int y = 0, k = 0; y < rows_; y++)
+	  {
+	    lcv = y + n2;
+	    for (int x = 0; x < columns_; x++, k++)
+	      {	    
+		rsum = gsum = bsum = 0;
+		count = 0;
+		
+		lcv2 = x + n2;
+		for (int y1 = y - n2; y1 < lcv; y1++)
 		  {
-		    for (int x1 = x - n2; x1 < x + n2; x1++)
+		    index = y1*columns_; 
+		    if (y1 >= 0 && y1 < rows_)
 		      {
-			if (x1 >= 0 && x1 < columns_)
+			for (int x1 = x - n2; x1 < lcv2; x1++)
 			  {
-			    int pixel = raster_[y1*columns_ + x1];
-			    rtab[count] = (pixel >> 16) & 0xff;
-			    gtab[count] = (pixel >> 8) & 0xff;
-			    btab[count] = (pixel) & 0xff;
-			    count++;
+			    if (x1 >= 0 && x1 < columns_)
+			      {
+				int pixel = raster_[index + x1];
+				rtab[count] = (pixel >> 16) & 0xff;
+				gtab[count] = (pixel >> 8) & 0xff;
+				btab[count] = (pixel) & 0xff;
+				count++;
+			      }
 			  }
 		      }
 		  }
-	      }
-	    
-	    for (int d = count/2; d > 0; d=d/2)
-	      {
-		for (int i = d; i < count; i++)
-		  {		    
-		    for (int j = i - d; j >= 0 && rtab[j] > rtab[j+d]; j -= d)
-		      {
-			int t = rtab[j];
-			rtab[j] = rtab[j + d];
-			rtab[j + d] = t;			
-		      }
-		    
-		    for (int j = i - d; j >= 0 && gtab[j] > gtab[j+d]; j -= d)
-		      {
-			int t = gtab[j];
-			gtab[j] = gtab[j + d];
-			gtab[j + d] = t;			
-		      }
-		    
-		    for (int j = i - d; j >= 0 && btab[j] > btab[j+d]; j -= d)
-		      {
-			int t = btab[j];
-			btab[j] = btab[j + d];
-			btab[j + d] = t;			
+		
+		for (int d = count >> 1; d > 0; d >>= 1)
+		  {
+		    for (int i = d; i < count; i++)
+		      {		    
+			for (int j = i - d; j >= 0 && rtab[j] > rtab[j+d]; j -= d)
+			  {
+			    int t = rtab[j];
+			    rtab[j] = rtab[j + d];
+			    rtab[j + d] = t;			
+			  }
+			
+			for (int j = i - d; j >= 0 && gtab[j] > gtab[j+d]; j -= d)
+			  {
+			    int t = gtab[j];
+			    gtab[j] = gtab[j + d];
+			    gtab[j + d] = t;			
+			  }
+			
+			for (int j = i - d; j >= 0 && btab[j] > btab[j+d]; j -= d)
+			  {
+			    int t = btab[j];
+			    btab[j] = btab[j + d];
+			    btab[j + d] = t;			
+			  }
 		      }
 		  }
+		
+		c2 = count >> 1;
+		
+		a = (raster_[k] >> 24) & 0xff;
+		r = ( (count % 2 == 0) ? (rtab[c2] + rtab[c2 - 1]) >> 1 : rtab[c2]);
+		g = ( (count % 2 == 0) ? (gtab[c2] + gtab[c2 - 1]) >> 1 : gtab[c2]);
+		b = ( (count % 2 == 0) ? (btab[c2] + btab[c2 - 1]) >> 1 : btab[c2]);
+		
+		pixels[k] = (a << 24) | (r << 16) | (g << 8) | b;
 	      }
-
-	    c2 = count/2;
-	    
-	    a = (raster_[y*columns_ + x] >> 24) & 0xff;
-	    r = ( (count % 2 == 0) ? (rtab[c2] + rtab[c2 - 1])/2 : rtab[c2]);
-	    g = ( (count % 2 == 0) ? (gtab[c2] + gtab[c2 - 1])/2 : gtab[c2]);
-	    b = ( (count % 2 == 0) ? (btab[c2] + btab[c2 - 1])/2 : btab[c2]);
-
-	    pixels[x] = (a << 24) | (r << 16) | (g << 8) | b;
 	  }
-
-	consumer.setPixels(0, y, columns_, 1, defaultRGB_, pixels, 0, columns_);	
       }
+
+    profile_timer_.stop();
     
+    consumer.setPixels(0, 0, columns_, rows_, defaultRGB_, pixels, 0, columns_);	
     consumer.imageComplete(status);
   }
 
diff --git a/java/ImageProcessing/filters/EdgeDetectFilter.java b/java/ImageProcessing/filters/EdgeDetectFilter.java
index 8855a757a46..87cc88d475d 100644
--- a/java/ImageProcessing/filters/EdgeDetectFilter.java
+++ b/java/ImageProcessing/filters/EdgeDetectFilter.java
@@ -15,124 +15,130 @@ public class EdgeDetectFilter extends SpatialFilter
 
   public void imageComplete(int status)
     {
-    Timer timer = new Timer();
-    
     if (status == IMAGEERROR || status == IMAGEABORTED)
       {
 	consumer.imageComplete(status);
 	System.out.println("Image Error");
 	return;
       }
+
+    System.gc();
     
-    int[] pixels = new int[columns_];
+    int[] pixels = new int[columns_*rows_];
     int pixel = 0;
     int red, green, blue;
-    int row1, row2, row3, row4, row5;
+    int row1, row2, row3;
     int new_red1 = 0, new_green1 = 0, new_blue1 = 0,
       new_red2 = 0, new_green2 = 0, new_blue2 = 0;
     int ul, um, ur, ll, lm, lr, ml, mr;
-    int alpha;
+    int alpha, lcv, lcv2;
 
-    for (int x = 1; x < rows_ - 1; x++)
+    profile_timer_.start();
+
+    for (int z = SpatialFilter.iterations_; z-- > 0;)
       {
-	for (int y = 1; y < columns_ - 1; y++)
+	lcv = rows_ - 1;
+	lcv2 = columns_ - 1;
+	for (int x = 1, index = 0; x < lcv; x++, index += columns_)
 	  {
-	    row1 = columns_*(x - 1) + y;
-	    row2 = row1 + columns_;
-	    row3 = row2 + columns_;
-
-	    ul = raster_[row1 - 1];
-	    um = raster_[row1];
-	    ur = raster_[row1 + 1];
-	    ml = raster_[row2 - 1];
-	    mr = raster_[row2 + 1];
-	    ll = raster_[row3 - 1];
-	    lm = raster_[row3];
-	    lr = raster_[row3 + 1];
-
-	    alpha = (raster_[row2] >> 24) & 0xff;
-	    
-	    new_red1 =
-	      (((ul >> 16) & 0xff)
-	       + (((um >> 16) & 0xff) << 1)
-	       + ((ur >> 16) & 0xff)
-	       - ((ll >> 16) & 0xff)
-	       - (((lm >> 16) & 0xff) << 1)
-	       - ((lr >> 16) & 0xff));
-
-	    new_green1 =
-	      (((ul >> 8) & 0xff)
-	       + (((um >> 8) & 0xff) << 1)
-	       + ((ur >> 8) & 0xff)
-	       - ((ll >> 8) & 0xff)
-	       - (((lm >> 8) & 0xff) << 1)
-	       - ((lr >> 8) & 0xff));
-
-	    new_blue1 =
-	      (((ul) & 0xff)
-	       + (((um) & 0xff) << 1)
-	       + ((ur) & 0xff)
-	       - ((ll) & 0xff)
-	       - (((lm) & 0xff) << 1)
-	       - ((lr) & 0xff));
-
-	    new_red2 =
-	      (- ((ul >> 16) & 0xff)
-	       + ((ur >> 16) & 0xff)
-	       - (((ml >> 16) & 0xff) << 1)
-	       + (((mr >> 16) & 0xff) << 1)
-	       - ((ll >> 16) & 0xff)
-	       + ((lr >> 16) & 0xff));
-
-	    new_green2 =
-	      (- ((ul >> 8) & 0xff)
-	       + ((ur >> 8) & 0xff)
-	       - (((ml >> 8) & 0xff) << 1)
-	       + (((mr >> 8) & 0xff) << 1)
-	       - ((ll >> 8) & 0xff)
-	       + ((lr >> 8) & 0xff));
-
-	    new_blue2 =
-	      (- ((ul) & 0xff)
-	       + ((ur) & 0xff)
-	       - (((ml) & 0xff) << 1)
-	       + (((mr) & 0xff) << 1)
-	       - ((ll) & 0xff)
-	       + ((lr) & 0xff));
-
-
-	    new_red1 = (int)Math.sqrt(new_red1*new_red1 + new_red2*new_red2);
-	    new_green1 = (int)Math.sqrt(new_green1*new_green1 + new_green2*new_green2);
-	    new_blue1 = (int)Math.sqrt(new_blue1*new_blue1 + new_blue2*new_blue2);
-	    
-	    if (new_red1 < 0) red = 0;
-	    if (new_green1 < 0) green = 0;
-	    if (new_blue1 < 0) blue = 0 ;
-	    
-      
-	    if (new_red1 > 255)
-	      new_red1 = 255;
-
-	    if (new_green1 > 255)
-	      new_green1 = 255;
-	    
-	    if (new_blue1 > 255)
-	      new_blue1 = 255;
-
-	    pixels[y - 1] = (alpha << 24) | (new_red1 << 16) | (new_green1 << 8) | new_blue1;
-
+	    for (int y = 1; y < lcv2; y++)
+	      {
+		row1 = index + y;
+		row2 = row1 + columns_;
+		row3 = row2 + columns_;
+		
+		ul = raster_[row1 - 1];
+		um = raster_[row1];
+		ur = raster_[row1 + 1];
+		ml = raster_[row2 - 1];
+		mr = raster_[row2 + 1];
+		ll = raster_[row3 - 1];
+		lm = raster_[row3];
+		lr = raster_[row3 + 1];
+		
+		alpha = (raster_[row2] >> 24) & 0xff;
+		
+		new_red1 =
+		  (((ul >> 16) & 0xff)
+		   + (((um >> 16) & 0xff) << 1)
+		   + ((ur >> 16) & 0xff)
+		   - ((ll >> 16) & 0xff)
+		   - (((lm >> 16) & 0xff) << 1)
+		   - ((lr >> 16) & 0xff));
+		
+		new_green1 =
+		  (((ul >> 8) & 0xff)
+		   + (((um >> 8) & 0xff) << 1)
+		   + ((ur >> 8) & 0xff)
+		   - ((ll >> 8) & 0xff)
+		   - (((lm >> 8) & 0xff) << 1)
+		   - ((lr >> 8) & 0xff));
+		
+		new_blue1 =
+		  (((ul) & 0xff)
+		   + (((um) & 0xff) << 1)
+		   + ((ur) & 0xff)
+		   - ((ll) & 0xff)
+		   - (((lm) & 0xff) << 1)
+		   - ((lr) & 0xff));
+		
+		new_red2 =
+		  (- ((ul >> 16) & 0xff)
+		   + ((ur >> 16) & 0xff)
+		   - (((ml >> 16) & 0xff) << 1)
+		   + (((mr >> 16) & 0xff) << 1)
+		   - ((ll >> 16) & 0xff)
+		   + ((lr >> 16) & 0xff));
+		
+		new_green2 =
+		  (- ((ul >> 8) & 0xff)
+		   + ((ur >> 8) & 0xff)
+		   - (((ml >> 8) & 0xff) << 1)
+		   + (((mr >> 8) & 0xff) << 1)
+		   - ((ll >> 8) & 0xff)
+		   + ((lr >> 8) & 0xff));
+		
+		new_blue2 =
+		  (- ((ul) & 0xff)
+		   + ((ur) & 0xff)
+		   - (((ml) & 0xff) << 1)
+		   + (((mr) & 0xff) << 1)
+		   - ((ll) & 0xff)
+		   + ((lr) & 0xff));
+		
+		
+		new_red1 = (int)Math.sqrt(new_red1*new_red1 + new_red2*new_red2);
+		new_green1 = (int)Math.sqrt(new_green1*new_green1 + new_green2*new_green2);
+		new_blue1 = (int)Math.sqrt(new_blue1*new_blue1 + new_blue2*new_blue2);
+		
+		if (new_red1 < 0) red = 0;
+		if (new_green1 < 0) green = 0;
+		if (new_blue1 < 0) blue = 0 ;
+		
+		
+		if (new_red1 > 255)
+		  new_red1 = 255;
+		
+		if (new_green1 > 255)
+		  new_green1 = 255;
+		
+		if (new_blue1 > 255)
+		  new_blue1 = 255;
+		
+		pixels[row2] = (alpha << 24) | (new_red1 << 16) | (new_green1 << 8) | new_blue1;		
+	      }
 	  }
-	consumer.setPixels(0, x-1, columns_, 1, defaultRGB_, pixels, 0, columns_);
       }
-    //    System.out.println(timer);
+
+    profile_timer_.stop();
+    
+    consumer.setPixels(0, 0, columns_, rows_, defaultRGB_, pixels, 0, columns_);
     consumer.imageComplete(status);
   }
 
-  /*  
+  /*
   public void imageComplete(int status)
   {
-    Timer timer = new Timer();
-    
     if (status == IMAGEERROR || status == IMAGEABORTED)
       {
 	consumer.imageComplete(status);
@@ -140,17 +146,19 @@ public class EdgeDetectFilter extends SpatialFilter
 	return;
       }
     
-    int[][] pixels = new int[rows_][columns_];
+    int[][] pixels = new int[rows_*columns_];
     int pixel = 0;
     int red, green, blue;
     int row1, row2, row3, row4, row5;
     int a, b, c, d, rsum, gsum, bsum, v, maxv = 0;
-    int ul, um, ur, ml, mr, ll, lm, lr;
+    int ul, um, ur, ml, mr, ll, lm, lr, lcv, lcv2;
     int alpha;
 
-    for (int y = 1; y < rows_ - 1; y++)
+    lcv = rows_ -1;
+    for (int y = 1; y < lcv; y++)
       {
-	for (int x = 1; x < columns_ - 1; x++)
+	lcv2 = columns_ -1;
+	for (int x = 1; x < lcv2; x++)
 	  {
 	    row1 = columns_*(y-1) + x;
 	    row2 = row1 + columns_;
@@ -202,7 +210,7 @@ public class EdgeDetectFilter extends SpatialFilter
 	    if (bsum > a) bsum = a;
 	    bsum /= 3;
 
-	    pixels[y][x] = (alpha << 24) | (rsum << 16) | (gsum << 8) | bsum;
+	    pixels[row2] = (alpha << 24) | (rsum << 16) | (gsum << 8) | bsum;
 
 	    v = (((int)(rsum)*11 + ((int)(gsum) << 4) + (int)(bsum)*5) >> 5);
 	    
@@ -230,13 +238,12 @@ public class EdgeDetectFilter extends SpatialFilter
 	    if (green > 255) green = 255;
 	    if (blue > 255) blue = 255;
 
-	    pixels[y][x] = (alpha << 24) | (red << 16) | (green << 8) | blue;
+	    pixels[y*x] = (alpha << 24) | (red << 16) | (green << 8) | blue;
 	  }
 
 	consumer.setPixels(0, y, columns_, 1, defaultRGB_, pixels[y], 0, columns_);
 	}
       
-    //    System.out.println(timer);
     consumer.imageComplete(status);
   }
   */
diff --git a/java/ImageProcessing/filters/EmbossFilter.java b/java/ImageProcessing/filters/EmbossFilter.java
index 3dd24cbbfa5..e6d5833ee39 100644
--- a/java/ImageProcessing/filters/EmbossFilter.java
+++ b/java/ImageProcessing/filters/EmbossFilter.java
@@ -16,59 +16,70 @@ public class EmbossFilter extends SpatialFilter
 
   public void imageComplete(int status)
   {
-    Timer timer = new Timer();
-    
     if (status == IMAGEERROR || status == IMAGEABORTED)
       {
 	consumer.imageComplete(status);
-	System.out.println("Image Error: " + status);
+	System.out.println("Emboss: Image Error: " + status);
 	return;
       }
+
+    System.out.println("Beginning to emboss an image.");
+    System.gc();
     
-    int[] pixels = new int[columns_];
+    int[] pixels = new int[columns_*rows_];
     int pixel = 0;
     int red, green, blue;
     int row1, row2, row3, ul, um, ml, mr, lm, lr;
-    int new_grey = 0;
+    int new_grey = 0, lcv, lcv2;
     int alpha;
 
-    for (int x = 1; x < rows_ - 1; x++)
-      {
-	for (int y = 1; y < columns_ - 1; y++)
-	  {
-
-	    row1 = columns_*(x - 1) + y;
-	    row2 = row1 + columns_;
-	    row3 = row2 + columns_;
-
-	    ul = raster_[row1 - 1];
-	    um = raster_[row1];
-	    ml = raster_[row2 - 1];
-	    mr = raster_[row2 + 1];
-	    lm = raster_[row3];
-	    lr = raster_[row3 + 1];
-
-	    alpha = (raster_[row2] >> 24) & 0xff;
-	    
-	    red = ((- (((ul >> 16) & 0xff) << 1) - ((um >> 16) & 0xff) -
-		    ((ml >> 16) & 0xff) + ((mr >> 16) & 0xff) +
-		    ((lm >> 16) & 0xff) + (((lr >> 16) & 0xff) << 1)) >> 3) + 128;
-
-	    green = ((- (((ul >> 8) & 0xff) << 1) - ((um >> 8) & 0xff) -
-		      ((ml >> 8) & 0xff) + ((mr >> 8) & 0xff) +
-		      ((lm >> 8) & 0xff) + (((lr >> 8) & 0xff) << 1)) >> 3) + 128;
-
-	    blue = ((- ((ul & 0xff) << 1) - (um & 0xff) -
-		     (ml & 0xff) + (mr & 0xff) +
-		     (lm & 0xff) + ((lr & 0xff) << 1)) >> 3) + 128;
-
-	    new_grey = (((int)(red)*11 + ((int)(green) << 4) + (int)(blue)*5) >> 5);
-	    
-	    pixels[y] = (alpha << 24) | (new_grey << 16) | (new_grey << 8) | new_grey;
+    profile_timer_.start();
 
+    for (int z = SpatialFilter.iterations_; z-- > 0;)
+      {    
+	lcv = rows_ -1;
+	for (int x = 1, index = 0; x < lcv; x++, index += columns_)
+	  {
+	    lcv2 = columns_ - 1;
+	    for (int y = 1; y < lcv2; y++)
+	      {
+		
+		row1 = index + y;
+		row2 = row1 + columns_;
+		row3 = row2 + columns_;
+		
+		ul = raster_[row1 - 1];
+		um = raster_[row1];
+		ml = raster_[row2 - 1];
+		mr = raster_[row2 + 1];
+		lm = raster_[row3];
+		lr = raster_[row3 + 1];
+		
+		alpha = (raster_[row2] >> 24) & 0xff;
+		
+		red = ((- (((ul >> 16) & 0xff) << 1) - ((um >> 16) & 0xff) -
+			((ml >> 16) & 0xff) + ((mr >> 16) & 0xff) +
+			((lm >> 16) & 0xff) + (((lr >> 16) & 0xff) << 1)) >> 3) + 128;
+		
+		green = ((- (((ul >> 8) & 0xff) << 1) - ((um >> 8) & 0xff) -
+			  ((ml >> 8) & 0xff) + ((mr >> 8) & 0xff) +
+			  ((lm >> 8) & 0xff) + (((lr >> 8) & 0xff) << 1)) >> 3) + 128;
+		
+		blue = ((- ((ul & 0xff) << 1) - (um & 0xff) -
+			 (ml & 0xff) + (mr & 0xff) +
+			 (lm & 0xff) + ((lr & 0xff) << 1)) >> 3) + 128;
+		
+		new_grey = (((int)(red)*11 + ((int)(green) << 4) + (int)(blue)*5) >> 5);
+		
+		pixels[row2] = (alpha << 24) | (new_grey << 16) | (new_grey << 8) | new_grey;
+		
+	      }
 	  }
-	consumer.setPixels(0, x, columns_, 1, defaultRGB_, pixels, 0, columns_);
       }
+
+    profile_timer_.stop();
+	
+    consumer.setPixels(0, 0, columns_, rows_, defaultRGB_, pixels, 0, columns_);
     //    System.out.println(timer);
     consumer.imageComplete(status);
   }
diff --git a/java/ImageProcessing/filters/OilPaintFilter.java b/java/ImageProcessing/filters/OilPaintFilter.java
index ccc01cc8d75..68bcf79e5c2 100644
--- a/java/ImageProcessing/filters/OilPaintFilter.java
+++ b/java/ImageProcessing/filters/OilPaintFilter.java
@@ -25,49 +25,73 @@ public class OilPaintFilter extends SpatialFilter
     if (status == IMAGEERROR || status == IMAGEABORTED)
       {
 	consumer.imageComplete(status);
-	System.out.println("Image Error: " + status);
+	System.out.println("Oil Paint FilterImage Error: " + status);
 	return;
       }
 
-    int[] pixels = new int[columns_];
+    System.gc();
+    
+    int[] pixels = new int[columns_*rows_];
     int[] nnrect = new int[degree_*degree_];
-    int offset = degree_/2, cnt = 0, maxcnt = 0, col = 0;
-
-    for (int y = offset; y < rows_ - offset; y++)
+    int offset = degree_/2, cnt = 0, maxcnt = 0, col = 0, tmp;
+    int lcv1 = rows_,
+      lcv2 = columns_,
+      lcv3 = degree_*degree_;
+    
+    profile_timer_.start();
+    
+    for (int z = SpatialFilter.iterations_; z-- > 0;)
       {
-	for (int x = offset; x < columns_ - offset; x++)
+	for (int y = 0, index = 0; y < lcv1; y++)
 	  {
-	    
-	    for (int i = 0; i < degree_*degree_; i++)
-	      nnrect[i] = raster_[(y + (i / degree_ - 1))*columns_ + (x + (i % degree_ - 1)) ];
-
-	    maxcnt = 0;
-	    col = 0;
-	    for (int i = 0; i < degree_*degree_; i++)
+	    for (int x = 0; x < lcv2; x++, index++)
 	      {
-		cnt = 1;
-
-		for (int j = i+1; j < degree_*degree_; j++)
+		cnt = 0;
+		for (int i = y - offset; i < y + offset; i++)
 		  {
-		    if (nnrect[i] == nnrect[j])
-		      cnt++;
-		  } 
+		    tmp = i*columns_;
+		    for (int j = x - offset; j < x + offset; j++, cnt++)
+		      {
+			if (i >= 0 && i < lcv1 && j >= 0 && j < lcv2)
+			  nnrect[cnt] = raster_[tmp + j];
+			else
+			  nnrect[cnt] = -1;
+		      }		    
+		  }
 		
-		if (cnt > maxcnt)
+		maxcnt = 0;
+		col = 0;
+		cnt = 0;
+		for (int i = 0; i < lcv3; i++)
 		  {
-		    col = nnrect[i];
-		    maxcnt = cnt;
+		    if (nnrect[i] != -1)
+		      {
+			cnt = 1;
+			
+			for (int j = i+1; j < lcv3; j++)
+			  {
+			    if (nnrect[i] == nnrect[j])
+			      cnt++;
+			  } 
+			
+			if (cnt > maxcnt)
+			  {
+			    col = nnrect[i];
+			    maxcnt = cnt;
+			  }
+		      }
 		  }
+		
+		pixels[index] = col;
 	      }
-
-	    pixels[x] = col;
 	  }
-
-	consumer.setPixels(0, y, columns_, 1, defaultRGB_, pixels, 0, columns_);
-	
       }
+
+    System.err.println("Oil Paint should be finished.");
+    
+    profile_timer_.stop();
     
+    consumer.setPixels(0, 0, columns_, rows_, defaultRGB_, pixels, 0, columns_);
     consumer.imageComplete(status);
   }
-
 }
diff --git a/java/ImageProcessing/filters/PixelizeFilter.java b/java/ImageProcessing/filters/PixelizeFilter.java
index c9a88677623..cdfe768789a 100644
--- a/java/ImageProcessing/filters/PixelizeFilter.java
+++ b/java/ImageProcessing/filters/PixelizeFilter.java
@@ -27,90 +27,91 @@ public class PixelizeFilter extends SpatialFilter
     if (status == IMAGEERROR || status == IMAGEABORTED)
       {
 	consumer.imageComplete(status);
-	System.out.println("Image Error: " + status);
+	System.out.println("Pixelize Image Error: " + status);
 	return;
       }
 
+    System.gc();
+    
     int pixel;
     int nsum, asum, rsum, gsum, bsum, nwide, nhigh, stx, sty, x, y;
-    int x_offset, y_offset, x_extent, y_extent;
-    int[] results = new int[pwidth_*pheight_];
-    
-    nwide = (columns_ + pwidth_ - 1) / pwidth_;
-    nhigh = (rows_ + pheight_ - 1) / pheight_;
+    int x_offset, y_offset, x_extent, y_extent, lcv, lcv2, lcv3, index;
+    int[] results = new int[rows_*columns_];
 
-    stx = -(nwide*pwidth_ - columns_)/2;
-    sty = -(nhigh*pheight_ - rows_)/2;
+    profile_timer_.start();
 
-    y = sty;
-    for (int i = 0; i < nhigh; i++, y += pheight_)
+    for (int z = SpatialFilter.iterations_; z-- > 0;)
       {
-	x = stx;
-
-	for (int j = 0; j < nwide; j++, x += pwidth_)
+	lcv3 = pwidth_*pheight_;
+	nwide = (columns_ + pwidth_ - 1) / pwidth_;
+	nhigh = (rows_ + pheight_ - 1) / pheight_;
+	
+	stx = -(nwide*pwidth_ - columns_)/2;
+	sty = -(nhigh*pheight_ - rows_)/2;
+	
+	y = sty;
+	for (int i = 0; i < nhigh; i++, y += pheight_)
 	  {
-	    nsum = asum = rsum = bsum = gsum = 0;
-	    
-	    for (int y1 = y; y1 < y + pheight_; y1++)
+	    x = stx;	    
+	    for (int j = 0; j < nwide; j++, x += pwidth_)
 	      {
-		for (int x1 = x; x1 < x + pwidth_; x1++)
+		nsum = asum = rsum = bsum = gsum = 0;
+		
+		lcv = y + pheight_;
+		lcv2 = x + pwidth_;
+		for (int y1 = y; y1 < lcv; y1++)
 		  {
-		    if (x1 >= 0 && y1 >= 0 && x1 < columns_ && y1 < rows_)
+		    index = y1*columns_;
+		    for (int x1 = x; x1 < lcv2; x1++)
 		      {
-			nsum++;
-			pixel = raster_[y1*columns_ + x1];
-			
-			asum += (pixel >> 24) & 0xff;
-			rsum += (pixel >> 16) & 0xff;
-			gsum += (pixel >> 8 ) & 0xff;
-			bsum += pixel & 0xff;
+			if (x1 >= 0 && y1 >= 0 && x1 < columns_ && y1 < rows_)
+			  {
+			    nsum++;
+			    pixel = raster_[index + x1];
+			    
+			    asum += (pixel >> 24) & 0xff;
+			    rsum += (pixel >> 16) & 0xff;
+			    gsum += (pixel >> 8 ) & 0xff;
+			    bsum += pixel & 0xff;
+			  }
 		      }
 		  }
-	      }
-
-	    if (nsum > 0)
-	      {
-		rsum /= nsum;
-		gsum /= nsum;
-		bsum /= nsum;
-
-		if (asum < 0) asum = 0;
-		if (rsum < 0) rsum = 0;
-		if (gsum < 0) gsum = 0;
-		if (bsum < 0) bsum = 0 ;
-
-		if (asum > 255) asum = 255;
-		if (rsum > 255) rsum = 255;
-		if (gsum > 255) gsum = 255;
-		if (bsum > 255) bsum = 255;
-
-	      }
-	    
-	    for (int k = 0; k < pwidth_*pheight_; k++)
-	      results[k] =  (asum << 24) | (rsum << 16) | (gsum << 8) | bsum;
-
-	    x_offset = x;
-	    y_offset = y;
-	    x_extent = pwidth_;
-	    y_extent = pheight_;
-	    
-	    if (x < 0)
-	      x_offset = -x;
-
-	    if (y < 0)
-	      y_offset = -y;
-
-	    if (x + pwidth_ > columns_)
-	      x_extent = x - columns_;
-
-	    if (y + pheight_ > rows_)
-	      y_extent = y - rows_;
-	    
-	    consumer.setPixels(x_offset, y_offset, x_extent, y_extent, defaultRGB_, results, 0, x_extent);
-	    	    
-	  }	
+		
+		if (nsum > 0)
+		  {
+		    rsum /= nsum;
+		    gsum /= nsum;
+		    bsum /= nsum;
+		    
+		    if (asum < 0) asum = 0;
+		    if (rsum < 0) rsum = 0;
+		    if (gsum < 0) gsum = 0;
+		    if (bsum < 0) bsum = 0;
+
+		    if (asum > 255) asum = 255;
+		    if (rsum > 255) rsum = 255;
+		    if (gsum > 255) gsum = 255;
+		    if (bsum > 255) bsum = 255;
+		    
+		  }
+		
+		for (int y1 = y; y1< lcv; y1++)
+		  {
+		    index = y1*columns_;
+		    for (int x1 = x; x1 < lcv2; x1++)
+		      {
+			if (x1 >= 0 && y1 >= 0 && x1 < columns_ && y1 < rows_)
+			  results[index + x1]
+			    = (asum << 24) | (rsum << 16) | (gsum << 8) | bsum;
+		      }
+		  }	    
+	      }	
+	  }
       }
-
+    
+    profile_timer_.stop();
+    
+    consumer.setPixels(0, 0, columns_, rows_, defaultRGB_, results, 0, columns_);
     consumer.imageComplete(status);
   }
 }
diff --git a/java/ImageProcessing/filters/RandomizeFilter.java b/java/ImageProcessing/filters/RandomizeFilter.java
new file mode 100644
index 00000000000..438f79e01c0
--- /dev/null
+++ b/java/ImageProcessing/filters/RandomizeFilter.java
@@ -0,0 +1,36 @@
+package imaging.filters;
+
+import java.awt.image.*;
+import java.util.Random;
+
+public class RandomizeFilter extends RGBImageFilter implements MedFilter
+{
+  private static Random rand = new Random(System.currentTimeMillis());
+  
+  public RandomizeFilter ()
+  {  
+    canFilterIndexColorModel = true;
+  }
+
+  public String info ()
+  {
+    return "Randomizes an image.";
+  }
+
+  public int filterRGB(int x, int y, int rgb)
+  {
+    DirectColorModel cm = 
+      (DirectColorModel)ColorModel.getRGBdefault();
+    
+    int    alpha = cm.getAlpha(rgb);
+    int    red   = rand.nextInt() % 255;
+    int    green = rand.nextInt() % 255;
+    int    blue  = rand.nextInt() % 255;
+    
+    alpha = alpha << 24;
+    red   = red   << 16;
+    green = green << 8;
+    
+    return alpha | red | green | blue;
+  }
+}
diff --git a/java/ImageProcessing/filters/RotateFilter.java b/java/ImageProcessing/filters/RotateFilter.java
index c646756359e..39551017a4b 100644
--- a/java/ImageProcessing/filters/RotateFilter.java
+++ b/java/ImageProcessing/filters/RotateFilter.java
@@ -150,8 +150,10 @@ public class RotateFilter extends SpatialFilter
     // it does, compute and store an appropriate color, otherwise skip
     // it.
 
+    System.gc();
+    
     double xf, yf, px, py, apx, apy;
-    int[] pixels = new int[rotwidth_];
+    int[] pixels = new int[rotwidth_*rotheight_];
     int ox, oy, ox1, oy1, index, pixel;
     double cx = (columns_ - 1) / 2;
     double cy = (rows_ - 1) / 2;
@@ -159,14 +161,18 @@ public class RotateFilter extends SpatialFilter
     int p0r = 0, p0g = 0, p0b = 0,
       p1r = 0, p1g = 0,p1b = 0,
       p2r = 0, p2g = 0, p2b = 0,
-      p3r = 0, p3g = 0, p3b = 0;
+      p3r = 0, p3g = 0, p3b = 0, lcv, lcv2;
     int rv,gv,bv, alpha;
     double rd,gd,bd, p0wgt = 0,
       p1wgt = 0, p2wgt = 0, p3wgt = 0, xfrac, yfrac;
-    
-    for (int y = roty_; y < roty_ + rotheight_; y++)
+
+    profile_timer_.start();
+
+    lcv = roty_ + rotheight_;
+    lcv2 = rotx_ + rotwidth_;
+    for (int y = roty_, i = 0; y < lcv; y++)
       {
-	for (int x = rotx_, i = 0; x < rotx_ + rotwidth_; x++, i++)
+	for (int x = rotx_; x < lcv2; x++, i++)
 	  {
 	    // Inverse rotate the point (x,y)
 	    // Inlining the call to rotatePoint
@@ -214,7 +220,8 @@ public class RotateFilter extends SpatialFilter
 		yfrac = yf - oy;
 		px = ((xfrac >= .5) ? (xfrac - .5) : (-.5 + xfrac));
 		py = ((yfrac >= .5) ? (yfrac - .5) : (-.5 + yfrac));
-		apx = Math.abs(px);  apy = Math.abs(py);
+		apx = ((px < 0) ? -px : px);
+		apy = ((py < 0) ? -py : py);
 		
 		/* get neighbor colors:  p0col, p1col, p2col, p3col */
 		ox1 = ox + ((px < 0.0) ? -1 : 1);
@@ -287,15 +294,17 @@ public class RotateFilter extends SpatialFilter
 		pixels[i] = (alpha << 24) | (rv << 16) | (gv << 8) | bv;
 	      }	       
 	  }
-	
-	consumer.setPixels(0, y - roty_, rotwidth_, 1, defaultRGB_,
-			   pixels, 0, rotwidth_);
       }
 
+    profile_timer_.stop();
+    
+    consumer.setPixels(0, 0, rotwidth_, rotheight_, defaultRGB_,
+		       pixels, 0, rotwidth_);
+
     consumer.imageComplete(status);
   }
 
-  private DoublePoint rotatePoint(int x, int y,
+  private final static DoublePoint rotatePoint(int x, int y,
 				  double cx, double cy, double rad)
     {
       /* rotate point x, y 'rad' radians around cx, cy, return rx, ry */
diff --git a/java/ImageProcessing/filters/SharpenFilter.java b/java/ImageProcessing/filters/SharpenFilter.java
index 079c2b93c91..fcb6f03c7ac 100644
--- a/java/ImageProcessing/filters/SharpenFilter.java
+++ b/java/ImageProcessing/filters/SharpenFilter.java
@@ -1,17 +1,18 @@
 package imaging.filters;
 
+import java.awt.Color;
 import java.awt.image.*;
 import java.util.*;
 
 public class SharpenFilter extends SpatialFilter
 {
-  double percentage_ = 75.0;
+  float percentage_ = (float)75.0;
   
   public SharpenFilter()
     {
     }
   
-  public SharpenFilter(double percentage)
+  public SharpenFilter(float percentage)
     {
       percentage_ = percentage;
     }
@@ -32,99 +33,121 @@ public class SharpenFilter extends SpatialFilter
 	  System.out.println("Image Error"); 
 	  return; 
 	}
+
+      System.gc();
       
-      HSV hsv;
-      RGB rgb;
-      int pixel, alpha;
-      int[] pixels = new int[columns_];
-      double fact, ifact, hue,sat,val, vsum;
-      double[] line0 = new double[columns_], 
-	linep1 = new double[columns_],
-	linem1 = new double[columns_],
+      float[] hsv = new float[3];
+      int rgb, red, green, blue;
+      int pixel, alpha, lcv, lcv2, lcv3;
+      int[] pixels = new int[columns_*rows_];
+      float fact, ifact, hue, sat, val, vsum;
+      float[] line0 = new float[columns_], 
+	linep1 = new float[columns_],
+	linem1 = new float[columns_],
 	tmpptr;
-
-      fact = percentage_/100.0;
-      ifact = 1.0 - fact;
       
-      for (int x = 0; x < columns_; x++)
-	{
-	  pixel = raster_[x];
-	  hsv = getHSV(((pixel >> 16) & 0xff), ((pixel >> 8) & 0xff), (pixel & 0xff));
-	  line0[x] = hsv.val_;
-	}
+      profile_timer_.start();
       
-      for (int x = columns_, index = 0; x < 2*columns_; x++, index++)
-	{
-	  pixel = raster_[x];
-	  hsv = getHSV(((pixel >> 16) & 0xff), ((pixel >> 8) & 0xff), (pixel & 0xff));
-	  linep1[index] = hsv.val_;
-	}
-
-      for (int y = 1; y < rows_ - 1; y++)
-	{
-	  tmpptr = linem1;
-	  linem1 = line0;
-	  line0 = linep1;
-	  linep1 = tmpptr;
-
-	  for (int x = columns_*(y+1), index= 0; x < columns_*(y+2); x++, index++)
+      for (int z = 0; z < SpatialFilter.iterations_; z++)
+	{          
+	  fact = percentage_/(float)100.0;
+	  ifact = (float)1.0 - fact;
+	  
+	  for (int x = 0; x < columns_; x++)
 	    {
 	      pixel = raster_[x];
-	      hsv = getHSV(((pixel >> 16) & 0xff), ((pixel >> 8) & 0xff), (pixel & 0xff));
-	      linep1[index] = hsv.val_;			   
+	      hsv = getHSV(((pixel >> 16) & 0xff), ((pixel >> 8) & 0xff), (pixel & 0xff),hsv);
+	      line0[x] = hsv[2];
 	    }
-
-	  for (int x = 1; x < columns_ - 1; x++)
+	  
+	  lcv = columns_ << 1;
+	  for (int x = columns_, index = 0; x < lcv; x++, index++)
 	    {
-	      vsum = 0.0;
-	      vsum = linem1[x-1] + linem1[x] + linem1[x+1] +
-		line0[x-1] + line0[x] + line0[x + 1] + 
-		linep1[x-1] + linep1[x] + linep1[x + 1];
-
-	      pixel = raster_[y*columns_ + x];
-	      alpha = (pixel >> 24) & 0xff;
-	      hsv = getHSV(((pixel >> 16) & 0xff), ((pixel >> 8) & 0xff), (pixel & 0xff));
-	      hsv.val_ = ((hsv.val_ - (fact * vsum) / 9) / ifact);
-	      if (hsv.val_ < 1.0)
+	      pixel = raster_[x];
+	      hsv = getHSV(((pixel >> 16) & 0xff), ((pixel >> 8) & 0xff), (pixel & 0xff),hsv);
+	      linep1[index] = hsv[2];
+	    }
+	  
+	  lcv = columns_ - 1;
+	  lcv2 = rows_ - 1;
+	  for (int y = 1, i = columns_; y < lcv2; y++)
+	    {
+	      tmpptr = linem1;
+	      linem1 = line0;
+	      line0 = linep1;
+	      linep1 = tmpptr;
+	      
+	      lcv3 = columns_*(y+2);
+	      for (int x = columns_*(y+1), index= 0; x < lcv; x++, index++)
 		{
-		  if (hsv.val_ < 0.0)
-		    hsv.val_ = 0.0;
+		  pixel = raster_[x];
+		  // Note hsv is only instantiated once
+		  hsv = getHSV(((pixel >> 16) & 0xff), ((pixel >> 8) & 0xff), (pixel & 0xff), hsv);
+		  linep1[index] = hsv[2];			   
 		}
-	      else
-		hsv.val_ = 1.0;
-
-	      rgb = getRGB(hsv.hue_, hsv.sat_, hsv.val_);
-
-	      if (rgb.red_ < 0) rgb.red_ = 0;
-	      if (rgb.green_ < 0) rgb.green_ = 0;
-	      if (rgb.blue_ < 0) rgb.blue_ = 0 ;
 	      
-	      if (rgb.red_ > 255) rgb.red_ = 255;
-	      if (rgb.green_ > 255) rgb.green_ = 255;
-	      if (rgb.blue_ > 255) rgb.blue_ = 255;
-
-	      pixels[x] =
-		(alpha << 24) | (rgb.red_ << 16) | (rgb.green_ << 8) | rgb.blue_;
+	      i++;
+	      for (int x = 1; x < lcv; x++, i++)
+		{
+		  vsum = (float)0.0;
+		  vsum = linem1[x-1] + linem1[x] + linem1[x+1] +
+		    line0[x-1] + line0[x] + line0[x + 1] + 
+		    linep1[x-1] + linep1[x] + linep1[x + 1];
+		  
+		  pixel = raster_[i];
+		  alpha = (pixel >> 24) & 0xff;
+		  hsv = getHSV(((pixel >> 16) & 0xff), ((pixel >> 8) & 0xff), (pixel & 0xff), hsv);
+		  
+		  val = ((hsv[2] - (fact * vsum) / 9) / ifact);	      
+		  if (val < 1.0)
+		    {
+		      if (val < 0.0)
+			val = (float)0.0;
+		    }
+		  else
+		    val = (float)1.0;
+		  
+		  hsv[2] = val;
+		  rgb = getRGB(hsv[0], hsv[1], hsv[2]);
+		  
+		  red = (rgb >> 16) & 0xff;
+		  green = (rgb >> 8) & 0xff;
+		  blue = rgb & 0xff;
+		  
+		  if (red < 0) red = 0;
+		  if (green < 0) green = 0;
+		  if (blue < 0) blue = 0 ;
+		  
+		  if (red > 255) red = 255;
+		  if (green > 255) green = 255;
+		  if (blue > 255) blue = 255;
+		  
+		  pixels[i] =
+		    (alpha << 24) | (red << 16) | (green << 8) | blue;
+		}
+	      i++;
 	    }
-	  
-	  consumer.setPixels(0, y, columns_, 1, defaultRGB_, pixels, 0, columns_); 	  
 	}
-     
-  
+      
+      profile_timer_.stop();
+
+      consumer.setPixels(0, 0, columns_, rows_, defaultRGB_, pixels, 0, columns_);
+      
       System.out.println("Finished altering image");
       consumer.imageComplete(status);
     }
   
   
-  static private HSV getHSV(int red, int green, int blue)
+  static private float[] getHSV(int red, int green, int blue, float[] hsv)
     {
-      double rd, gd, bd, max, min, del, rc, gc, bc; 
-      HSV hsv = new HSV(); 
+      float rd, gd, bd, max, min, del, rc, gc, bc, hue, sat;
+      if (hsv == null)
+	hsv = new float[3];
       
       /* convert RGB to HSV */ 
-      rd = red / 255.0;            /* rd,gd,bd range 0-1 instead of 0-255 */
-      gd = green / 255.0; 
-      bd = blue / 255.0; 
+      rd = red / (float)255.0;            /* rd,gd,bd range 0-1 instead of 0-255 */
+      gd = green / (float)255.0; 
+      bd = blue / (float)255.0; 
 
       /* compute maximum of rd,gd,bd */
       if (rd >= gd)
@@ -159,44 +182,45 @@ public class SharpenFilter extends SpatialFilter
 	}
 
       del = max - min;
-      hsv.val_ = max;
+      hsv[2] = max;
 
       if (max != 0.0)
-	hsv.sat_ = (del) / max;
+	sat = (del) / max;
       else
-	hsv.sat_ = 0.0;
+	sat = (float)0.0;
       
-      hsv.hue_ = -1;
+      hue = -1;
       
-      if (hsv.sat_ != 0.0)
+      if (sat != 0.0)
 	{
 	  rc = (max - rd) / del;
 	  gc = (max - gd) / del;
 	  bc = (max - bd) / del;
 
 	  if (rd == max)
-	    hsv.hue_ = bc - gc;
+	    hue = bc - gc;
 	  else
 	    if (gd == max)
-	      hsv.hue_ = 2 + rc - bc;
+	      hue = 2 + rc - bc;
 	    else
 	      if (bd == max)
-		hsv.hue_ = 4 + gc - rc;
+		hue = 4 + gc - rc;
 
-	  hsv.hue_ *= 60;
-	  if (hsv.hue_<0)
-	    hsv.hue_ += 360;
+	  hue *= 60;
+	  if (hue<0)
+	    hue += 360;
 	}
-      
+
+      hsv[0] = hue;
+      hsv[1] = sat;
       return hsv;
     }
 
-  static private RGB getRGB(double hue, double sat, double val)
+  static private int getRGB(float hue, float sat, float val)
     {
-      int    j;
-      double rd, gd, bd;
-      double f, p, q, t;
-      RGB rgb = new RGB();
+      int    j, r, g, b;
+      float rd, gd, bd;
+      float f, p, q, t;
       
       /* convert HSV back to RGB */
       if (hue == -1 || sat == 0.0)
@@ -205,13 +229,13 @@ public class SharpenFilter extends SpatialFilter
 	}
       else
 	{
-	  if (hue==360.0) hue = 0.0;
-	  hue = hue / 60.0;
-	  j = (int) Math.floor(hue);
+	  if (hue==(float)360.0) hue = (float)0.0;
+	  hue = hue / (float)60.0;
+	  j = (int) hue;
 	  if (j<0) j=0;          /* either hue or floor seem to go neg on some sys */
 	  f = hue - j;
-	  p = val * (1-sat);
-	  q = val * (1 - (sat*f));
+	  p = val * (1-sat); // val - sat* val
+	  q = val * (1 - (sat*f)); // val - val*sat*f
 	  t = val * (1 - (sat*(1 - f)));
 	  
 	  switch (j) {
@@ -224,29 +248,15 @@ public class SharpenFilter extends SpatialFilter
 	  default: rd = val;  gd = t;  bd = p;  break;  /* never happen */
 	  }
 	}
+      r = (int)(rd * 255.0 + 0.5);
+      g = (int)(gd * 255.0 + 0.5);
+      b = (int)(bd * 255.0 + 0.5);
       
-      rgb.red_ = (int) Math.floor((rd * 255.0) + 0.5);
-      rgb.green_ = (int) Math.floor((gd * 255.0) + 0.5);
-      rgb.blue_ = (int) Math.floor((bd * 255.0) + 0.5);
-
-      
-      return rgb;
+      return 0xff000000 | (r << 16) | (g << 8) | b;
     }
 }  
 
-class HSV
-{
-  public double hue_;
-  public double sat_;
-  public double val_;
-}
 
-class RGB
-{
-  public int red_;
-  public int green_;
-  public int blue_;
-}
 
 
 
diff --git a/java/ImageProcessing/filters/SpatialFilter.java b/java/ImageProcessing/filters/SpatialFilter.java
index 1b6fb8d615d..ad56164819e 100644
--- a/java/ImageProcessing/filters/SpatialFilter.java
+++ b/java/ImageProcessing/filters/SpatialFilter.java
@@ -1,6 +1,7 @@
 package imaging.filters;
 
 import java.awt.image.*;
+import JACE.Timers.ProfileTimer;
 
 public class SpatialFilter extends ImageFilter implements MedFilter
 {
@@ -33,6 +34,16 @@ public class SpatialFilter extends ImageFilter implements MedFilter
     return "Base Filter class. Doesn't do much";
   }
 
+  public long filterTime()
+    {
+      return profile_timer_.elapsedTime();
+    }
+
+  public static void setTimer(int internal_iterations)
+    {
+      iterations_ = internal_iterations;
+    }
+  
   public void setDimensions(int width, int height)
   {
     rows_ = height;
@@ -186,16 +197,17 @@ public class SpatialFilter extends ImageFilter implements MedFilter
     return new_raster;
   }
 
-  protected int intensity(int rd, int gn, int bl)
+  protected static final int intensity(int rd, int gn, int bl)
     {
       return (((int)(rd)*11 + (int)(gn)*16 + (int)(bl)*5) >> 5);
     }
 
-  protected static ColorModel defaultRGB_ = ColorModel.getRGBdefault();
+  protected static int iterations_ = 1;
+  protected static final  ColorModel defaultRGB_ = ColorModel.getRGBdefault();
   protected int[][] matrix_;
   protected int[] raster_;
   protected int rows_ = 0, columns_ = 0;
   protected int div_factor_ = 1, offset_, degree_;
   protected int raster_offset_ = 0;
-
+  protected final ProfileTimer profile_timer_ = new ProfileTimer();
 }
diff --git a/java/ImageProcessing/filters/SpreadFilter.java b/java/ImageProcessing/filters/SpreadFilter.java
index 7d14be9ec1a..c78790c9235 100644
--- a/java/ImageProcessing/filters/SpreadFilter.java
+++ b/java/ImageProcessing/filters/SpreadFilter.java
@@ -28,97 +28,103 @@ public class SpreadFilter extends SpatialFilter
     if (status == IMAGEERROR || status == IMAGEABORTED)
       {
 	consumer.imageComplete(status);
-	System.out.println("Image Error: " + status);
+	System.out.println("Spread Image Error: " + status);
 	return;
       }
 
+    System.gc();
+    
     Random rand = new Random();
-    int[] pixels = new int[columns_];
+    int[] pixels = new int[columns_*rows_];
     int d, dx, dy, x1, y1, xrng, xoff, yrng, yoff;
     int minx, maxx, miny, maxy, rdist, tmp;
-    
-    for (int y = 0; y < rows_; y++)
-      {
 
-	for (int x = 0; x < columns_; x++)
-	  {
+    profile_timer_.start();
 
-	    if (pwidth_ < 0)
+    for (int z = 0; z < SpatialFilter.iterations_; z++)
+      {    
+	for (int y = 0, i=0; y < rows_; y++)
+	  {
+	    for (int x = 0; x < columns_; x++, i++)
 	      {
-		d = (pwidth_ < 0 ? -pwidth_ : pwidth_);
-
-		minx = x - d;
-		if (minx < 0)
-		  minx = 0;
-
-		maxx = x + d;
-		if (maxx >= columns_)
-		  maxx = columns_ - 1;
-
-		tmp = rand.nextInt();
-		tmp = (tmp < 0 ? -tmp : tmp);
-		x1 = minx + tmp % ((maxx - minx) + 1);
+		if (pwidth_ < 0)
+		  {
+		    d = (pwidth_ < 0 ? -pwidth_ : pwidth_);
+		    
+		    minx = x - d;
+		    if (minx < 0)
+		      minx = 0;
+		    
+		    maxx = x + d;
+		    if (maxx >= columns_)
+		      maxx = columns_ - 1;
+		    
+		    tmp = rand.nextInt();
+		    tmp = (tmp < 0 ? -tmp : tmp);
+		    x1 = minx + tmp % ((maxx - minx) + 1);
+		    
+		    miny = y - d;
+		    if (miny < 0)
+		      miny = 0;
+		    
+		    maxy = y + d;
+		    if (maxy >= rows_)
+		      maxy = rows_ - 1;
+		    
+		    rdist = d - (x1 < x ? -(x1 - x) : x1 - x);
+		    if (y - miny > rdist)
+		      miny = (y - rdist);
+		    if (maxy - y > rdist)
+		      maxy = (y + rdist);
+		    
+		    tmp = rand.nextInt();
+		    tmp = (tmp < 0 ? -tmp : tmp);
+		    y1 = miny + tmp % ((maxy - miny) + 1);
+		  }
+		else
+		  {
+		    minx = x - pwidth_;
+		    if (minx < 0)
+		      minx = 0;
+		    
+		    maxx = x + pwidth_;
+		    if (maxx >= columns_)
+		      maxx = columns_ - 1;
+		    
+		    tmp = rand.nextInt();
+		    tmp = (tmp < 0 ? -tmp : tmp);
+		    x1 = minx + tmp % ((maxx - minx) + 1);
+		    
+		    miny = y - pheight_;
+		    if (miny < 0)
+		      miny = 0;
+		    
+		    maxy = y + pheight_;
+		    if (maxx >= columns_)
+		      maxx = columns_ - 1;
+		    
+		    tmp = rand.nextInt();
+		    tmp = (tmp < 0 ? -tmp : tmp);
+		    y1 = miny + tmp % ((maxy - miny) + 1);
+		  }
 		
-		miny = y - d;
-		if (miny < 0)
-		  miny = 0;
-
-		maxy = y + d;
-		if (maxy >= rows_)
-		  maxy = rows_ - 1;
-
-		rdist = d - (x1 < x ? -(x1 - x) : x1 - x);
-		if (y - miny > rdist)
-		  miny = (y - rdist);
-		if (maxy - y > rdist)
-		  maxy = (y + rdist);
-
-		tmp = rand.nextInt();
-		tmp = (tmp < 0 ? -tmp : tmp);
-		y1 = miny + tmp % ((maxy - miny) + 1);
-	      }
-	    else
-	      {
-		minx = x - pwidth_;
-		if (minx < 0)
-		  minx = 0;
-
-		maxx = x + pwidth_;
-		if (maxx >= columns_)
-		  maxx = columns_ - 1;
-
-		tmp = rand.nextInt();
-		tmp = (tmp < 0 ? -tmp : tmp);
-		x1 = minx + tmp % ((maxx - minx) + 1);
-
-		miny = y - pheight_;
-		if (miny < 0)
-		  miny = 0;
-
-		maxy = y + pheight_;
-		if (maxx >= columns_)
-		  maxx = columns_ - 1;
-
-		tmp = rand.nextInt();
-		tmp = (tmp < 0 ? -tmp : tmp);
-		y1 = miny + tmp % ((maxy - miny) + 1);
-	      }
-
-	    if (x1 >= 0 && y1 >= 0 && x1 < columns_ && y1 < rows_)
-	      {
-		int pixel = raster_[y1*columns_ + x1];
-		int alpha = (pixel >> 24) & 0xff;
-		int red = (pixel >> 16) & 0xff;
-		int green = (pixel >> 8) & 0xff;
-		int blue = pixel & 0xff;
-
-		pixels[x] = (alpha << 24) | (red << 16) | (green << 8) | blue;
+		if (x1 >= 0 && y1 >= 0 && x1 < columns_ && y1 < rows_)
+		  {
+		    int pixel = raster_[i];
+		    int alpha = (pixel >> 24) & 0xff;
+		    int red = (pixel >> 16) & 0xff;
+		    int green = (pixel >> 8) & 0xff;
+		    int blue = pixel & 0xff;
+		    
+		    pixels[i] = (alpha << 24) | (red << 16) | (green << 8) | blue;
+		  }
 	      }
 	  }
-
-	consumer.setPixels(0, y, columns_, 1, defaultRGB_, pixels, 0, columns_);
       }
+
+    profile_timer_.stop();
     
+    consumer.setPixels(0, 0, columns_, rows_, defaultRGB_, pixels, 0, columns_);
     consumer.imageComplete(status);
   }
 }