I've written a small program that processes black and white images pixel by pixel to determine how how many of the neighbouring pixels are black or white. Then based on this value it changes the colour of the pixel in question.

My problem is that the quality of the output images seems to be significantly lower than the input image. I'm not sure if this is an error with my code or what.

 The original images were created using Adobe Illustrator and have a resolution of 1280 x 800 and are 72 DPI.

Here is my code:

2. //Define PImage variables
3. PImage source;
4. PImage destination;
5. String baseName = "File_";
6. boolean more;
7. int z=0;
8. int t=0;
9. color white = color(255);
10. color black = color(0);
11.                      
12. void setup()
13. {
14.   size (1280,800);
15.   do
16.   {   
17.     for (z=1; z<9999; z++)
18.     {
19.       
20.       //Load source image
21.       more = new File(baseName+nf(z,4)+".png").exists();
22.       source = loadImage(baseName+nf(z,4)+".png");
23.       
24.       //Create destination image
25.       destination = createImage(source.width, source.height, ALPHA);
26.   
27.       //Look at both images pixels
28.       source.loadPixels();
29.       destination.loadPixels();
30.   
31.       //Set the size of the scanning matrix
32.       int matrixsize = 27;
33.   
34.       //Loop through every pixel column
35.       for ( int x = 0; x < source.width; x++)
36.       {
37.         //Loop through every pixel row
38.         for (int y = 0; y < source.height; y++)
39.         {
40.           //Calculate 1D pixel location
41.           int loc = x + y * source.width;
42.           //Determine colour of current pixel
43.           color pix = source.pixels[loc];
44.           destination.pixels[loc] = black;
45.       
46.           //If current pixel colour is white examine if the colour needs changing the colour
47.           if ( pix == white)
48.           {
49.         
50.             //Pass the x  y coordinates and matrix info to the perimeterFeature metho
51.             //perimeterFeature method then scans the surronding pixels and returns a new colour
52.             color newPix = perimeterFeature(x,y,matrixsize,source);
53.             //Set pixel colour to new value
54.             destination.pixels[loc] = newPix;
55.           }
56.       
57.           /*else
58.           {
59.             destination.pixels[loc] = black;
60.           }*/
61.         }
62.       }
63.   
64.       //Update pixels in destination
65.       destination.updatePixels();
66.   
67.       //Display the destination image
68.       image(destination,0,0); 
69. 
    
70.       //Counter to save the files with even numbers 
71.       t = t+2; 
72.       
73.       //Save image
74.       save(baseName+nf(t,4)+".png"); 
75.     }    
76.   }while(more);     
77. }
78. 
    
79. void draw()
80. {
81. 
    
82. }
83. 
    
84. color perimeterFeature(int x, int y, int matrixsize, PImage img) 
85. {
86.   int countWhitePixels = 0;
87.   int offset = matrixsize / 2;
88.   // Loop through convolution matrix
89.   for (int i = 0; i < matrixsize; i++)
90.   {
91.     for (int j= 0; j < matrixsize; j++)
92.     {
93.       // What pixel are we testing
94.       int xloc = x+i-offset;
95.       int yloc = y+j-offset;
96.       int loc = xloc + img.width*yloc;
97.       // Make sure we have not walked off the edge of the pixel array
98.       loc = constrain(loc,0,img.pixels.length-1);
99.       
100.       //Colour of the current pixel
101.       color pix = img.pixels[loc];
102.                 
103.       //if the colour of the current pixel is white count it
104.       if (pix == white)
105.       {
106.         countWhitePixels = countWhitePixels + 1;      
107.       }
108.       
109.       else
110.       {
111.         countWhitePixels = countWhitePixels + 0; 
112.       }            
113.     }
114.   }
115.  
116.   if(countWhitePixels > 0)
117.   {
118.     if (countWhitePixels < 729)
119.     { 
120.       if (countWhitePixels < 625)
121.       {
122.         if (countWhitePixels < 529)
123.         {
124.           countWhitePixels = 255;
125.         }
126.       
127.         else
128.         {
129.           countWhitePixels =0;
130.         }        
131.       }
132.       
133.       else
134.       {
135.         countWhitePixels =0;
136.       }     
137.     }
138.        
139.     else
140.     {
141.       countWhitePixels = 0;
142.     }     
143.   }
144.   
145.   else
146.   {
147.     countWhitePixels = 0;
148.   }
149.     
150.   // Make sure colour is within range
151.   countWhitePixels = constrain(countWhitePixels,0,255);
152.   // Return the resulting color
153.   return color(countWhitePixels);
154. }

Input image

Output image:

You can see the loss in definition around the edges of the circle, which should have small teeth but dont in the second image.

Can anyone offer any advice as to why there is such a difference between the image quality?

I've written a program that grayscales pixels depending on the colour of the neighbouring pixels. I only want to grayscale the pixel if it is white so the first step is to scan through the image pixel by pixel to determine the colour of the pixel. If the pixel is white then the location of the pixel is passed to a method that scans the neighbouring pixels and counts the number of neighbouring white pixels. Based on how many neighbouring pixels are white the colour of the center pixel is then altered.

I want to use this program to process thousands of images (up to 9999), however as the images are processed the program becomes increasingly slow. Do you have any tips as to how I can improve the speed of the image processing?

Thanks

2. //Define PImage variables
3. PImage source;
4. PImage destination;
5. String baseName = "MRobot_";
6. boolean more;
7. int z=1;
8. int even = 2 ;
9.                      
10. void setup()
11. {
12.   size (1280,800);
13. }
14. 
    
15. void draw()
16. {
17.   do
18.   {
19.     for (z=1; z<9999; z++)
20.     {
21.        //Load source image
22.        source = loadImage(baseName+nf(z,4)+".png");
23.        more = new File(baseName+nf(z,4)+".png").exists();
24.        destination = createImage(source.width, source.height, ALPHA);
25.          
26.       //Look at both image's pixels
27.       source.loadPixels();
28.       destination.loadPixels();
29.   
30.       //Set the size of the scanning matrix
31.       int matrixsize = 3;
32.   
33.       //Loop through every pixel column
34.       for ( int x = 0; x < source.width; x++)
35.       {
36.         //Loop through every pixel row
37.         for (int y = 0; y < source.height; y++)
38.         {
39.           //Calculate 1D pixel location
40.           int loc = x + y * source.width;
41.           //Determine colour of current pixel
42.           color pix = source.pixels[loc];
43.       
44.           //If current pixel colour is white examine if the colour needs changing the colour
45.           if ( pix == color(255))
46.           {       
47.             //Pass the x  y coordinates and matrix info to the greyscale method
48.             //greyscale method then scans the surronding pixels and returns a new colour
49.             color newPix = greyscale(x,y,matrixsize,source);
50.             //Set pixel colour to new value
51.             destination.pixels[loc] = newPix;
52.           }
53.       
54.           else
55.           {
56.             destination.pixels[loc] = color(0); //black
57.           }
58.         }
59.       }
60.        
61.       //Update pixels in destination
62.       destination.updatePixels();
63.   
64.       //Set background to black
65.       background(0);
66.   
67.       //Display the destination image
68.       image(destination,0,0); 
69.                   
70.       for (even=2; even<z*2; even = even +2)
71.       {
72.         //Save image with even number
73.         save(baseName+nf(even,4)+".png");  
74.       }        
75.     }
76.     
77.   }while(more);
78.     
79. }
80. 
    
81. //Method to greyscale a pixel based on the surronding pixel colours
82. color greyscale(int x, int y, int matrixsize, PImage img) 
83. {
84.   int greyvalue = 0;
85.   int offset = matrixsize / 2;
86.   // Loop through scanning matrix
87.   for (int i = 0; i < matrixsize; i++)
88.   {
89.     for (int j= 0; j < matrixsize; j++)
90.     {
91.       // What pixel are we testing
92.       int xloc = x+i-offset;
93.       int yloc = y+j-offset;
94.       int loc = xloc + img.width*yloc;
95.       // Make sure we have not walked off the edge of the pixel array
96.       loc = constrain(loc,0,img.pixels.length-1);
97.       
98.       //Colour of the current pixel
99.       color pix = img.pixels[loc];
100.       
101.       //if the colour of the current pixel is white
102.       // add one to "greyvalue"
103.       if (pix == color(255))
104.       {
105.         greyvalue = greyvalue + 1;      
106.       }
107.       
108.       else
109.       {
110.         greyvalue = greyvalue + 0; 
111.       }            
112.     }
113.   }
114.  
115.  //Means that there is a least one white pixel within the scanning matrix
116.   if(greyvalue > 0)
117.   {
118.     //Measn there is at least one black pixel within the scanning matrix
119.     if (greyvalue < 9)
120.     { 
121.        greyvalue = 255; //white 
122.     }
123.     
124.     else
125.     {
126.       greyvalue = 100; //grey
127.     }     
128.   }
129.   
130.   else
131.   {
132.     greyvalue = 0; //black
133.   }
134.     
135.   // Make sure colour is within range
136.   greyvalue = constrain(greyvalue,0,255);
137.   // Return the resulting color
138.   return color(greyvalue);
139. }