The idea is to have the kinect facing people moving etc, and for the sketch to display the pixels being sorted live on screen.

At the moment the idea of it is working alright, however i've executed it pretty poorly and it's running very slowly. Ideally I'd like it to run at a reasonable framerate, however I've set the framerate to 60 and it's definitely not running anywhere near that. I'm guessing it's probably something to do with the efficiency of it, or something to do with arrays looping infinitely, but I'm not too too sure.

Thanks in advancement for any help/ ideas of things to look at to help me with this.

2. /* OpenProcessing Tweak of *@*http://www.openprocessing.org/sketch/27745*@* */
3. /* !do not delete the line above, required for linking your tweak if you re-upload */
4. 
   
5. import processing.video.*;
6. import processing.opengl.*;
7. import org.openkinect.*;
8. import org.openkinect.processing.*;
9. 
   
10. // Kinect Library object
11. Kinect kinect;
12. 
    
13. float deg = 20; // Start at 15 degrees
14. 
    
15. int[] colors;
16. float mainY = 0;
17. int mainStep = 0;
18. int CURRENTSORTING = 0;
19. String sortingName = "quickSort";
20. PImage colorImage;
21. 
    
22. void setup() {
23. 
    
24.   //size (640, 480);
25.   //width = 640;
26.   //height = 480;
27.   size(1280, 720);
28.   //background(190, 90, 90);  
29.   frameRate(60);
30.     
31.   kinect = new Kinect(this);
32.   kinect.start();
33.   kinect.enableRGB(true);
34.   //kinect.enableIR(false);
35.   //kinect.enableDepth(false);
36.   kinect.processDepthImage(false);  
37.   kinect.tilt(deg);
38. 
    
39.   colors = new int[width];
40.  
41. }
42. 
    
43. void draw() {
44.  
45.   colorImage = kinect.getVideoImage();
46.   image(colorImage,0,0);
47.   scale(2.5);  
48.   colorImage.updatePixels();
49.   //tint(255, 126);
50.   //width = 640;
51.   //height = 480;
52. 
    
53.   smooth();
54.   doSort();
55.   //colorImage.updatePixels();
56.   //image(colorImage,0,0);
57. 
    
58.   
59.  // sortedImage = colorImage.get();
60.   //sortedImage.loadPixels();
61.   
62.   //image(colorImage,0,0);
63.   
64. }
65. 
    
66. void doSort() {
67.   
68.   //colorImage = kinect.getVideoImage();
69.   //image(colorImage,0,0);
70.   //colorImage.loadPixels();
71.   
72.   mainY = 0;
73.   mainStep = 0;
74.   //background(0);
75.   // fill colors array
76.   int imageY = (int)random(colorImage.height);
77.   for(int i=0;i<width;i++) {
78.   colors[i] = colorImage.get(i, imageY); 
79. 
    
80.   }
81.   //background(255);
82.   smooth();
83.   
84.   switch(CURRENTSORTING) {
85.   case 0:
86.     quickSort(colors,0,colors.length-1);
87.     break;
88.   case 1:
89.     bubbleSort(colors);  
90.     break;
91.   case 2:
92.     selectionSort(colors);
93.     break;
94.   case 3:
95.     insertionSort(colors);
96.     break;
97.   case 4:
98.     shellsort(colors);
99.     break;
100.   case 5:
101.     heapSort(colors);
102.     break;
103.   }
104. }
105. 
     
106. /*
107.  * draw the values of given array as colors
108.  */
109. void drawArray(int[] array) {
110.   for(int i=0;i<array.length;i++) {
111.     stroke(array[i]);
112.     line(i, mainY, i, mainY+1);
113.   }
114.   mainY++;
115. }
116. 
     
117. // ------ quicksort             --------- //
118. 
     
119. int partition(int arr[], int left, int right)
120. {
121.   int i = left, j = right;
122.   int tmp;
123.   int pivot = arr[(left + right)/2];
124.   int counting = 0;
125.   while (i <= j) {
126.     if(mainStep++ % 8 == 0) drawArray(arr);
127.     while (arr[i] < pivot)
128.       i++;
129.     while (arr[j] > pivot)
130.       j--;
131.     if (i <= j) {
132.       tmp = arr[i];
133.       arr[i] = arr[j];
134.       arr[j] = tmp;
135.       i++;
136.       j--;
137.     }
138.   };
139. 
     
140.   return i;
141. }
142. 
     
143. void quickSort(int arr[], int left, int right) {
144.   int index = partition(arr, left, right);
145.   if (left < index - 1) {
146.     quickSort(arr, left, index - 1);
147.   }
148.   if (index < right) {
149.     quickSort(arr, index, right);
150.   }
151. }
152. 
     
153. 
     
154. // ------ selection sort             --------- //
155. 
     
156. public void selectionSort(int[] arr) {
157.   int i, j, minIndex, tmp;
158.   int n = arr.length;
159.   for (i = 0; i < n - 1; i++) {
160.     minIndex = i;
161.     for (j = i + 1; j < n; j++)
162.       if (arr[j] < arr[minIndex])
163.         minIndex = j;
164.     if (minIndex != i) {
165.       tmp = arr[i];
166.       arr[i] = arr[minIndex];
167.       arr[minIndex] = tmp;
168.       if(mainStep++%2==0) drawArray(arr);
169.       
170.     }
171.   }
172. }
173. 
     
174. 
     
175. // ------ insertion sort             --------- //
176. 
     
177. void insertionSort(int[] arr) {
178.   int i, j, newValue;
179.   int counts = 0;
180.   for (i = 1; i < arr.length; i++) {
181.     newValue = arr[i];
182.     j = i;
183.     while (j > 0 && arr[j - 1] > newValue) {
184.       arr[j] = arr[j - 1];
185.       j--;
186.     }
187.     arr[j] = newValue;
188.     if(mainStep++%2==0) drawArray(arr);
189.   }
190. }
191. 
     
192. // ------ bubble sort             --------- //
193. public void bubbleSort(int[] a)
194. {
195.   int out, in;
196.   int nElems = a.length;
197.   int counts = 0;
198.   for(out=nElems-1; out>1; out--) {
199. 
     
200.     for(in=0; in<out; in++) {
201.       if( a[in] > a[in+1] ) {
202.         swap(a, in, in+1);
203.       }
204.     }
205.     if(counts++%2 == 0) drawArray(a);
206.   }
207. }
208. 
     
209. private void swap(int[] a, int one, int two)
210. {
211.   int temp = a[one];
212.   a[one] = a[two];
213.   a[two] = temp;
214. }
215. 
     
216. 
     
217. // ------ shell sort             --------- //
218. 
     
219. void shellsort(int[] a)
220. {
221.   int i, j, k, h, t;
222.   int n = n=a.length;
223.   int[] cols = {
224.     1391376, 463792, 198768, 86961, 33936,
225.     13776, 4592, 1968, 861, 336, 112, 48, 21, 7, 3, 1
226.   };
227.   int steps = 0;
228.   for (k=0; k<16; k++)
229.   {
230.     h=cols[k];
231.     steps++;
232.     for (i=h; i<n; i++)
233.     {
234.       j=i;
235.       t=a[j];
236.       steps++;
237.       while (j>=h && a[j-h]>t)
238.       {
239.         a[j]=a[j-h];
240.         j=j-h;
241.         steps++;
242.       }
243.       a[j]=t;
244.       if(steps % 12 == 0) drawArray(a);
245.     }
246.   }
247. }
248. 
     
249. 
     
250. // heapsort
251. void sift (int[] a, int l, int r) { 
252.   int i, j;
253.   int x;
254.   i = l; 
255.   x = a[l];
256.   j = 2*i+1;
257.   if ((j<r) && (a[j+1]<a[j])) j++;
258.   while ((j<=r) && (a[j] < x)) {
259.     a[i] = a[j];
260.     i    = j; 
261.     j    = j*2+1;
262.     if ((j<r) && (a[j+1]<a[j])) j++;
263.   }
264.   a[i] = x;
265. }
266. 
     
267. // ------ heap sort             --------- //
268. void heapSort (int[] a) { 
269.   int l,r,n,tmp;
270.   n = a.length;
271.   for (l=(n-2)/2; l>=0; l--)
272.       sift(a,l,n-1);
273.   for (r=n-1; r>0; r--) {
274.     tmp  = a[0];
275.     a[0] = a[r];
276.     a[r] = tmp;
277.     sift(a, 0, r-1);
278.     if(mainStep++%2==0)drawArray(a);
279.   }
280. }
281. 
     
282. void mousePressed() {
283.   save(sortingName + "_" + (System.currentTimeMillis()/1000) + ".tif");
284.   print("SAVED");
285. }
286. 
     
287. 
     
288. void keyPressed() {
289.   
290.     if (key == CODED){
291.     if (keyCode == UP){
292.       deg++;
293.     }
294.     else if (keyCode == DOWN){
295.       deg--;
296.     }
297.     deg = constrain(deg,0,30);
298.     kinect.tilt(deg);
299.   }
300.   if(key == '0') {
301.     CURRENTSORTING = 0;
302.     sortingName = "quickSort";
303.     print("Quick_Sort");
304.     print(" ");
305.   }
306.   if(key == '1') {
307.     CURRENTSORTING = 1;
308.     sortingName = "bubbleSort";
309.     print("Bubble_Sort");
310.     print(" ");
311.   }
312.   if(key == '2') {
313.     CURRENTSORTING = 2;
314.     sortingName = "selectionSort";
315.     print("Selection_Sort");
316.     print(" ");
317.   }
318.   if(key == '3') {
319.     CURRENTSORTING = 3;
320.     sortingName = "insertionSort";
321.     print("Insertion_Sort");    
322.     print(" ");
323.   }
324.   if(key == '4') {
325.     CURRENTSORTING = 4;
326.     sortingName = "shellSort";
327.     print("Shell_Sort");    
328.     print(" ");
329.   }
330.   if(key == '5') {
331.     CURRENTSORTING = 5;
332.     sortingName = "heapSort";
333.     print("Heap_Sort");    
334.     print(" ");
335.   }
336.   doSort();
337. }
338. 
     
339. void stop() {
340.   kinect.quit();
341.   super.stop();
342. }

Cheers