I've been looking at modifying another sketch to read and manipulate a folder full of images in sequence but I'm not having much luck. 

The modifications I've made to Kim Asendorf's ASDFPixelSort sketch have allowed it to read all the image files in a folder, but not only can I not get it to load the whole list, it doesn't even sort the first image anymore (which is the only file it does load).

Here's my alternation:

1. 
   
3. int mode = 1;
4. 
   
5. //MODE:
6. //0 -> black
7. //1 -> bright
8. //2 -> white
9. //b(16777216)
10. 
    
11. java.io.FilenameFilter jpgFilter = new java.io.FilenameFilter() {
12.   boolean accept(File dir, String name) {
13.     return name.toLowerCase().endsWith(".jpg");
14.   }
15. };
16. 
    
17. PImage img;
18. //String FileName = "Tri.jpg";
19. File dir;
20. String[] list;
21. 
    
22. int loops = 1;
23. 
    
24. int blackValue = -16000000;
25. int brigthnessValue = 50;
26. int whiteValue = -13000000;
27. 
    
28. int row = 0;
29. int column = 0;
30. 
    
31. boolean saved = false;
32. 
    
33. void setup() {
34.   size(1920, 1080);
35.   dir = new File(dataPath("images"));
36.  list = dir.list(jpgFilter);
37. }
38. 
    
39. 
    
40. void draw() {
41.   
42.   for (int i = 0; i < list.length; i=i+1) {
43.   println(list[i]);  
44.   img = loadImage(dataPath("images/" + list[i]));
45.   background(loadImage(dataPath("images/" + list[i])));
46.   loadPixels();  
47.   while(column < width-1) {
48.     img.loadPixels(); 
49.     sortColumn();
50.     column++;
51.     img.updatePixels();
52.   }
53.   
54.   while(row < height-1) {
55.     img.loadPixels(); 
56.     sortRow();
57.     row++;
58.     img.updatePixels();
59.   }
60.   
61.   image(img,0,0);
62.   if(!saved && frameCount >= loops) {
63.     saveFrame(list[i]);
64.     saved = true;
65.     println("DONE "+list[i]);
66.     
67.   }
68.     }
69. }
70. 
    
71. void sortRow() {
72.   int x = 0;
73.   int y = row;
74.   int xend = 0;
75.   
76.   while(xend < width-1) {
77.     switch(mode) {
78.       case 0:
79.         x = getFirstNotBlackX(x, y);
80.         xend = getNextBlackX(x, y);
81.         break;
82.       case 1:
83.         x = getFirstBrightX(x, y);
84.         xend = getNextDarkX(x, y);
85.         break;
86.       case 2:
87.         x = getFirstNotWhiteX(x, y);
88.         xend = getNextWhiteX(x, y);
89.         break;
90.       default:
91.         break;
92.     }
93.     
94.     if(x < 0) break;
95.     
96.     int sortLength = xend-x;
97.     
98.     color[] unsorted = new color[sortLength];
99.     color[] sorted = new color[sortLength];
100.     
101.     for(int i=0; i<sortLength; i++) {
102.       unsorted[i] = img.pixels[x + i + y * img.width];
103.     }
104.     
105.     sorted = sort(unsorted);
106.     
107.     for(int i=0; i<sortLength; i++) {
108.       img.pixels[x + i + y * img.width] = sorted[i];      
109.     }
110.     
111.     x = xend+1;
112.   }
113. }
114. 
     
115. 
     
116. void sortColumn() {
117.   int x = column;
118.   int y = 0;
119.   int yend = 0;
120.   
121.   while(yend < height-1) {
122.     switch(mode) {
123.       case 0:
124.         y = getFirstNotBlackY(x, y);
125.         yend = getNextBlackY(x, y);
126.         break;
127.       case 1:
128.         y = getFirstBrightY(x, y);
129.         yend = getNextDarkY(x, y);
130.         break;
131.       case 2:
132.         y = getFirstNotWhiteY(x, y);
133.         yend = getNextWhiteY(x, y);
134.         break;
135.       default:
136.         break;
137.     }
138.     
139.     if(y < 0) break;
140.     
141.     int sortLength = yend-y;
142.     
143.     color[] unsorted = new color[sortLength];
144.     color[] sorted = new color[sortLength];
145.     
146.     for(int i=0; i<sortLength; i++) {
147.       unsorted[i] = img.pixels[x + (y+i) * img.width];
148.     }
149.     
150.     sorted = sort(unsorted);
151.     
152.     for(int i=0; i<sortLength; i++) {
153.       img.pixels[x + (y+i) * img.width] = sorted[i];
154.     }
155.     
156.     y = yend+1;
157.   }
158. }
159. 
     
160. 
     
161. //BLACK
162. int getFirstNotBlackX(int _x, int _y) {
163.   int x = _x;
164.   int y = _y;
165.   color c;
166.   while((c = img.pixels[x + y * img.width]) < blackValue) {
167.     x++;
168.     if(x >= width) return -1;
169.   }
170.   return x;
171. }
172. 
     
173. int getNextBlackX(int _x, int _y) {
174.   int x = _x+1;
175.   int y = _y;
176.   color c;
177.   while((c = img.pixels[x + y * img.width]) > blackValue) {
178.     x++;
179.     if(x >= width) return width-1;
180.   }
181.   return x-1;
182. }
183. 
     
184. //BRIGHTNESS
185. int getFirstBrightX(int _x, int _y) {
186.   int x = _x;
187.   int y = _y;
188.   color c;
189.   while(brightness(c = img.pixels[x + y * img.width]) < brigthnessValue) {
190.     x++;
191.     if(x >= width) return -1;
192.   }
193.   return x;
194. }
195. 
     
196. int getNextDarkX(int _x, int _y) {
197.   int x = _x+1;
198.   int y = _y;
199.   color c;
200.   while(brightness(c = img.pixels[x + y * img.width]) > brigthnessValue) {
201.     x++;
202.     if(x >= width) return width-1;
203.   }
204.   return x-1;
205. }
206. 
     
207. //WHITE
208. int getFirstNotWhiteX(int _x, int _y) {
209.   int x = _x;
210.   int y = _y;
211.   color c;
212.   while((c = img.pixels[x + y * img.width]) > whiteValue) {
213.     x++;
214.     if(x >= width) return -1;
215.   }
216.   return x;
217. }
218. 
     
219. int getNextWhiteX(int _x, int _y) {
220.   int x = _x+1;
221.   int y = _y;
222.   color c;
223.   while((c = img.pixels[x + y * img.width]) < whiteValue) {
224.     x++;
225.     if(x >= width) return width-1;
226.   }
227.   return x-1;
228. }
229. 
     
230. 
     
231. //BLACK
232. int getFirstNotBlackY(int _x, int _y) {
233.   int x = _x;
234.   int y = _y;
235.   color c;
236.   if(y < height) {
237.     while((c = img.pixels[x + y * img.width]) < blackValue) {
238.       y++;
239.       if(y >= height) return -1;
240.     }
241.   }
242.   return y;
243. }
244. 
     
245. int getNextBlackY(int _x, int _y) {
246.   int x = _x;
247.   int y = _y+1;
248.   color c;
249.   if(y < height) {
250.     while((c = img.pixels[x + y * img.width]) > blackValue) {
251.       y++;
252.       if(y >= height) return height-1;
253.     }
254.   }
255.   return y-1;
256. }
257. 
     
258. //BRIGHTNESS
259. int getFirstBrightY(int _x, int _y) {
260.   int x = _x;
261.   int y = _y;
262.   color c;
263.   if(y < height) {
264.     while(brightness(c = img.pixels[x + y * img.width]) < brigthnessValue) {
265.       y++;
266.       if(y >= height) return -1;
267.     }
268.   }
269.   return y;
270. }
271. 
     
272. int getNextDarkY(int _x, int _y) {
273.   int x = _x;
274.   int y = _y+1;
275.   color c;
276.   if(y < height) {
277.     while(brightness(c = img.pixels[x + y * img.width]) > brigthnessValue) {
278.       y++;
279.       if(y >= height) return height-1;
280.     }
281.   }
282.   return y-1;
283. }
284. 
     
285. //WHITE
286. int getFirstNotWhiteY(int _x, int _y) {
287.   int x = _x;
288.   int y = _y;
289.   color c;
290.   if(y < height) {
291.     while((c = img.pixels[x + y * img.width]) > whiteValue) {
292.       y++;
293.       if(y >= height) return -1;
294.     }
295.   }
296.   return y;
297. }
298. 
     
299. int getNextWhiteY(int _x, int _y) {
300.   int x = _x;
301.   int y = _y+1;
302.   color c;
303.   if(y < height) {
304.     while((c = img.pixels[x + y * img.width]) < whiteValue) {
305.       y++;
306.       if(y >= height) return height-1;
307.     }
308.   }
309.   return y-1;
310. }
311.   
312.   

Would love some help if you have any ideas,

cheers,

Steve

I'm new to processing as of a week or two and diving in head first!

I've been experimenting with lots of open source pixel sorting sketches and I'm looking to process a batch of still video frames, in .jpg form, for the purpose of recompilation into video. No luck so far and I was wondering if anyone would be willing to point out the error in my code or in the right direction.

I'm getting a NullPointerException error at the for line right after my void draw() statement

thanks in advance for taking a look!

2. 
   
3. import java.util.Date;
4. 
   
5. PImage img;
6. Date d = new Date();
7. long timestamp = d.getTime()/1000; 
8. 
   
9. File dir = new File(dataPath("images"));
10. String[] list = dir.list();
11. 
    
12. void setup() {
13.   size(1080,720);
14. }
15. 
    
16. 
    
17. 
    
18. void draw() {
19.  
20. for (int x = 0; x < list.length; x++);{
21. 
    
22.   img = loadImage("list[x]");
23. }
24.   background(img);
25.   loadPixels();  
26.   for (int y = 0; y<height; y+=1 ) {
27.     for (int x = 0; x<width; x+=1) {
28.       int loc = x + y*img.width;
29.       float r = red (img.pixels[loc]);
30.       float g = green (img.pixels[loc]);
31.       float b = blue (img.pixels[loc]);
32.       float av = ((r+g+b)/3.0);
33. 
    
34.     pushMatrix();
35.     translate(x,y);
36.       stroke(r,g,b);
37.       if (r > 30 && r < 255) {
38.         line(0,0,(av-255)/1,0); //change these values to alter the length. The closer to 0 the longer the lines. 
39.                                 // goose note: see 255? the number right after that, which should be 1 by default in my copy, is the easiest one to change for line length. try decimals for longer ones!
40.                                 // you can also try different shapes or even bezier curves instead of line();
41.       }
42.     popMatrix(); 
43.       
44.     }
45. 
    
46.   }
47.   
48. 
    
49.   
50. println("done");
51. noLoop();
52. save("sort"+timestamp+".png");
53. }