2. import TUIO.*;
3. TuioProcessing tuioClient;
4. 
   
5. import java.util.*; //ADD THIS LINE TO BE ABLE TO USE TUIOCLIENT WITH PROCESSING 2+
6. 
   
7. // these are some helper variables which are used
8. // to create scalable graphical feedback
9. float cursor_size = 15;
10. float object_size = 60;
11. float table_size = 760;
12. float scale_factor = 1;
13. PFont font;
14. 
    
15. void setup()
16. {
17.   //size(screen.width,screen.height);
18.   size(640,480);
19.   stroke(10);
20.   fill(0);
21.   
22.   loop();
23.   frameRate(60);
24.   //noLoop();
25.   
26.  // hint(ENABLE_NATIVE_FONTS);
27.   font = createFont("Arial", 18);
28.   scale_factor = height/table_size;
29.   
30.   // we create an instance of the TuioProcessing client
31.   // since we add "this" class as an argument the TuioProcessing class expects
32.   // an implementation of the TUIO callback methods (see below)
33.   tuioClient  = new TuioProcessing(this);
34. }
35. 
    
36. // within the draw method we retrieve a Vector (List) of TuioObject and TuioCursor (polling)
37. // from the TuioProcessing client and then loop over both lists to draw the graphical feedback.
38. void draw()
39. {
40.   background(255);
41.   textFont(font,18*scale_factor);
42.   float obj_size = object_size*scale_factor; 
43.   float cur_size = cursor_size*scale_factor; 
44.    
45.   Vector tuioObjectList = tuioClient.getTuioCursor();
46.   
47.   
48.   for (int i=0;i<tuioObjectList.size();i++) {
49.      TuioObject tobj = (TuioObject)tuioCursorList.elementAt(i);
50.      stroke(0);
51.      fill(0);
52.      pushMatrix();
53.      translate(tobj.getScreenX(width),tobj.getScreenY(height));
54.      rotate(tobj.getAngle());
55.      rect(-obj_size/2,-obj_size/2,obj_size,obj_size);
56.      popMatrix();
57.      fill(255);
58.      text(""+tobj.getSymbolID(), tobj.getScreenX(width), tobj.getScreenY(height));
59.    }
60. 
    
61.   
62.    Vector tuioCursorList = tuioClient.getTuioCursors();
63.    for (int i=0;i<tuioCursorList.size();i++) {
64.       TuioCursor tcur = (TuioCursor)tuioCursorList.elementAt(i);
65.       Vector pointList = tcur.getPath();
66.       
67.       if (pointList.size()>0) {
68.         stroke(5);
69.        TuioPoint start_point = (TuioPoint)pointList.firstElement();;
70.         for (int j=0;j<pointList.size();j++) {
71.            TuioPoint end_point = (TuioPoint)pointList.elementAt(j);
72.            line(start_point.getScreenX(width),start_point.getScreenY(height),end_point.getScreenX(width),end_point.getScreenY(height));
73.            start_point = end_point;
74.         }
75. 
    
76. 
    
77.         
78.         
79.         /*
80.         stroke(10);
81.         fill(192,192,192);
82.         ellipse( tcur.getScreenX(width), tcur.getScreenY(height),cur_size,cur_size);
83.         fill(0);
84.         text(""+ tcur.getCursorID(),  tcur.getScreenX(width)-5,  tcur.getScreenY(height)+5);
85.         */
86.       }
87.    }
88.    
89. }
90. 
    
91. 
    
92. // these callback methods are called whenever a TUIO event occurs
93. 
    
94. // called when an object is added to the scene
95. 
    
96. 
    
97. void addTuioObject(TuioObject tobj) {
98.   println("add object "+tobj.getSymbolID()+" ("+tobj.getSessionID()+") "+tobj.getX()+" "+tobj.getY()+" "+tobj.getAngle());
99. }
100. 
     
101. // called when an object is removed from the scene
102. 
     
103. void removeTuioObject(TuioObject tobj) {
104.   println("remove object "+tobj.getSymbolID()+" ("+tobj.getSessionID()+")");
105. }
106. 
     
107. 
     
108. // called when an object is moved
109. void updateTuioObject (TuioObject tobj) {
110.   println("update object "+tobj.getSymbolID()+" ("+tobj.getSessionID()+") "+tobj.getX()+" "+tobj.getY()+" "+tobj.getAngle()
111.           +" "+tobj.getMotionSpeed()+" "+tobj.getRotationSpeed()+" "+tobj.getMotionAccel()+" "+tobj.getRotationAccel());
112. }
113. 
     
114. // called when a cursor is added to the scene
115. void addTuioCursor(TuioCursor tcur) {
116.   println("add cursor "+tcur.getCursorID()+" ("+tcur.getSessionID()+ ") " +tcur.getX()+" "+tcur.getY());
117. }
118. 
     
119. // called when a cursor is moved
120. void updateTuioCursor (TuioCursor tcur) {
121.   println("update cursor "+tcur.getCursorID()+" ("+tcur.getSessionID()+ ") " +tcur.getX()+" "+tcur.getY()
122.           +" "+tcur.getMotionSpeed()+" "+tcur.getMotionAccel());
123. }
124. 
     
125. // called when a cursor is removed from the scene
126. 
     
127. void removeTuioCursor(TuioCursor tcur) {
128.   println("remove cursor "+tcur.getCursorID()+" ("+tcur.getSessionID()+")");
129. }
130. 
     
131. 
     
132. // called after each message bundle
133. // representing the end of an image frame
134. 
     
135. 
     
136. void refresh(TuioTime bundleTime) { 
137.   redraw();
138. }

2. class TRAIN{
3. 
   
4. 
   
5.   ////train movements/////
6.   
7.   //ADD :  SOUND, SMOKE, LIGHT
8. 
   
9. float xpos, ypos;    // Starting position of shape    
10. 
    
11. float xspeed = 15;  // Speed of the shape
12. 
    
13. 
    
14. //////////////////////////
15. 
    
16. 
    
17. 
    
18. TRAIN(){
19.   xpos = displayWidth*1.92;
20.   ypos = displayHeight/2.3;
21.   
22. }
23. 
    
24. 
    
25. 
    
26. 
    
27. 
    
28. void display(){
29.   xpos = xpos - xspeed ;
30.   
31.   
32.   if (xpos < displayWidth-displayWidth*2.6) {
33.     
34.     xpos = displayWidth*1.92;
35.   }
36.   
37.   train.resize(500, 130);
38.     image(train,xpos--, ypos); 
39. g.removeCache(train);
40. 
    
41. if(xpos <= 1800 && xpos > -200){
42.   
43.     player.start();
44. 
    
45. }
46. 
    
47. println(xpos);
48. }
49. 
    
50. }

2. cellOne[] mover = new cellOne[30];
4. void setup()
5. {
6.   
7.   size(displayWidth, displayHeight, P3D);
8. 
   
9.   
10.   for (int i = 0; i < mover.length; i ++ ) { // Initialize each Car using a for loop.
11.     mover[i] = new cellOne(); 
12.   }
13. 
    
14. }
15. 
    
16. void draw(){
17. 
    
18. 
    
20. 
    
21.       for (int i = 0; i < mover.length; i++) {
22.  
23.  
24.   
25.          mover[i].update();
26.  mover[i].checkEdges();
27.     mover[i].display();
28.       }
29. }
30. 
    

2. class cellOne{
3.   color c = color(100,50,77);
4. float x,y;
5.      PVector location;
6.   PVector velocity;
7.   PVector acceleration;
8.   float topspeed;
9.   float r = 48;
10.  
11.   cellOne(){
12.     location = new PVector(random(displayWidth), random(displayHeight));
13.     velocity = new PVector(0, 0);
14.     topspeed = .8;
15.     
16.      x = random(2);
17.     y = random(2);
18.     
19.   }
20.     
21. 
    
22.   void update() {
23. 
    
24.     acceleration = PVector.random2D();
25.     acceleration.mult(random(2));
26. 
    
27.     velocity.add(acceleration);
28.     velocity.limit(topspeed);
29.     location.add(velocity);
30.   }
31. 
    
32.   void display() {
33.     stroke(0);
34.     strokeWeight(2);
35.     fill(127);
36.     ellipse(location.x, location.y, r,r);
37.   }
38.   
39.    void filler() {
40.     stroke(0);
41.     strokeWeight(2);
42.     fill(2);
43.     ellipse(location.x, location.y, r,r);
44.   }
45. 
    
46.   void checkEdges() {
47. 
    
48. 
    
49.      
50.     if (location.x > displayWidth) {
51.       location.x = 0;
52.     } 
53.     else if (location.x < 0) {
54.       location.x = displayWidth;
55.     }
56. 
    
57.     if (location.y > displayHeight) {
58.       location.y = 0;
59.     } 
60.     else if (location.y < 0) {
61.       location.y = displayHeight;
62.     }
63.   }
64. 
    
65. 
    
66. 
    
67.  boolean intersect() {
68.     
69.     // Objects can be passed into functions as arguments too! 
70.     float distance = dist(x,y,location.x,location.y); // Calculate distance
71.     //location.add(r);
72.     // Compare distance to sum of radii
73.     if (distance <r) {
74.       return true;
75.     } else {
76.       return false;
77.     }
78.   }
79. }

The constructor (MYsketchName.Cover, String) is undefined. 

code below (highlighted changed/added parts):

2. /**
3.  Quick Cover Flow in Processing
4.  by Adrià Navarro http://adrianavarro.net 
5.  USING: 3D (openGL), events (controlp5) and animation (ani)
6.  TODO: image resize, background image loading
7.  */
8. 
   
9. import controlP5.*;
10. import processing.opengl.*;
11. import de.looksgood.ani.*;
12. import java.io.*;
13. import java.util.Arrays; 
14. import java.util.Comparator; 
15. 
    
16. import gifAnimation.*;
17. 
    
18. 
    
19. ControlP5 controlP5;
20. Button bNext, bPrev;
21. Slider slider;
22. 
    
23. //image path where all images are stored
24. String path = "../images/";
25. 
    
26. 
    
27. //create Arraylist of covers
28. ArrayList<Cover> covers;
29. 
    
30. PImage imgMask;
31. PImage imgShadow;   
32. Ani coverAnimation;
33. 
    
34. float ANI_TIME = 0.5;
35. int selectedCover = 0;
36. 
    
37. /* -------------- INIT -------------- */
38. void setup() {
39.   size(800, 400, OPENGL);
40.   smooth();
41.   noStroke();
42. 
    
43.   //read filepath
44.   File folder = new File(dataPath(path));
45.   
46.   //filters jpgs
47.   File[] initialfiles = folder.listFiles(jpgFilter);
48. 
    
49.   //sorts files by modification date
50.   Comparator<File> byModificationDate = new ModificationDateCompare();
51.   Arrays.sort(initialfiles, byModificationDate);
52. 
    
53.   
54.   imgMask = loadImage("mask.png");
55.   imgShadow = loadImage("shadow.png");
56. 
    
57.   // Init interface controlP5
58.   controlP5 = new ControlP5(this);
59.   bPrev =    controlP5.addButton("Prev",-1, 20, 360, 80, 20);     // ((theName, theValue, theX, theY, theW, theH);
60.   bNext =    controlP5.addButton("Next", 1, width-100, 360, 80, 20);
61.   //slider =   controlP5.addSlider("slider", 0, 200, selectedCover, 120, 360, width - 240, 20); // (theName, theMin, theMax, theDefaultValue, theX, theY, theW, theH);
62.   //slider.setLabelVisible(false);
63.   //controlP5.setAutoDraw(false);
64. 
    
65.   // Init Ani
66.   Ani.init(this);
67. 
    
68.   
69.   // Init covers
70.   covers = new ArrayList<Cover>();
71. 
    
72.   //Add covers to from initialfiles
73.   for (int i=0; i<initialfiles.length; i++ ) {
74.     covers.add(new Cover(initialfiles[i].getAbsolutePath()));
75.   }
76.   //println(covers);
77.   initCovers();
78. }
79. 
    
80. /* -------------- DRAW LOOP -------------- */
81. void draw() {
82.   background(0);
83.   hint(ENABLE_DEPTH_TEST);
84.   boolean newimage = checkForImage(covers.size());
85.   if (newimage) {
86.     newimage = false;
87.   }
88.   
89.   // move to the center to have easier coordinates
90.   pushMatrix();
91.   translate(width / 2, 200 ); 
92.   for( int i=0; i<covers.size(); i++ ) {
93.     covers.get(i).drawCover();
94.   }
95.   popMatrix();  
96. 
    
97.   // disable depth test to draw control interface on top of everything
98.   hint(DISABLE_DEPTH_TEST);
99.   image(imgShadow, 0.0, 0.0);
100.   //controlP5.draw(); //needed if we draw with p3d
101. }
102. 
     
103. 
     
104. /* -------------- EVENT MANAGEMENT -------------- */
105. public void controlEvent(ControlEvent theEvent) {
106. 
     
107.   // Check where the event comes from
108.   if (theEvent.controller().name() == "slider" ) {           // slider
109.     selectedCover = round(theEvent.controller().value());
110.   }
111.   else {                                                    // buttons
112.     selectedCover += (int) theEvent.controller().value();
113.     //slider.setValue(selectedCover);
114.   }
115. 
     
116.   //println(names);
117.   // Lock buttons if we are in the first or last cover
118.   if ( selectedCover == covers.size() ) {
119.     selectedCover --;
120.     bNext.lock();
121.   }
122.   else if ( selectedCover < 0 ) {
123.     selectedCover ++;
124.     bPrev.lock();
125.   }
126.   else {
127.     bNext.unlock();
128.     bPrev.unlock();
129.   }
130. 
     
131.   //Call Animation
132.   moveCovers();
133. }
134. 
     
135. /* -------------- ANIMATION TWEENS -------------- */
136. public void initCovers() {
137.   covers.get(0).position.set(0.0 - 0.0, 0.0, 75.0);
138.   covers.get(0).rotationY = 0.0;
139.   for (int i=1; i<covers.size(); i++ ) {
140.     covers.get(i).position.set(150.0 + 25.0*i, 0.0, 0.0);
141.     covers.get(i).rotationY = -QUARTER_PI;
142.   }
143. }
144. 
     
145. public void moveCovers() {
146. 
     
147.   // left covers
148.   for (int i=0; i<selectedCover; i++ ) {
149.     Ani.to(covers.get(i).position, ANI_TIME, "x", -150.0 - 25.0*(selectedCover-i), Ani.CIRC_OUT);
150.     Ani.to(covers.get(i).position, ANI_TIME, "y", 0.0, Ani.CIRC_OUT);
151.     Ani.to(covers.get(i).position, ANI_TIME, "z", 0.0, Ani.CIRC_OUT);
152.     Ani.to(covers.get(i), ANI_TIME, "rotationY", QUARTER_PI, Ani.CIRC_OUT);
153.   }
154. 
     
155.   // central cover
156.   coverAnimation = Ani.to(covers.get(selectedCover).position, 0.5, "x", 0.0, Ani.CIRC_OUT);
157.   Ani.to(covers.get(selectedCover).position, ANI_TIME, "y", 0.0, Ani.CIRC_OUT);
158.   Ani.to(covers.get(selectedCover).position, ANI_TIME, "z", 75.0, Ani.CIRC_OUT);
159.   Ani.to(covers.get(selectedCover), ANI_TIME, "rotationY", 0.0, Ani.CIRC_OUT);
160. 
     
161.   // right covers
162.   for (int i=selectedCover + 1; i<covers.size(); i++ ) {
163.     Ani.to(covers.get(i).position, ANI_TIME, "x", 150.0 + 25.0*(i-selectedCover), Ani.CIRC_OUT);
164.     Ani.to(covers.get(i).position, ANI_TIME, "y", 0.0, Ani.CIRC_OUT);
165.     Ani.to(covers.get(i).position, ANI_TIME, "z", 0.0, Ani.CIRC_OUT);
166.     Ani.to(covers.get(i), ANI_TIME, "rotationY", -QUARTER_PI, Ani.CIRC_OUT);
167.   }
168. }
169. 
     
170. boolean checkForImage(int number) {
171.   File folder = new File(dataPath(path));
172.   File[] files = folder.listFiles(jpgFilter);
173.   //sorts files by modification date
174.   Comparator<File> byModificationDate = new ModificationDateCompare();
175.   Arrays.sort(files, byModificationDate);
176.   if (files.length > number) {
177.     for (int i=number; i<files.length; i++ ) {
178.       covers.add(new Cover(files[i].getAbsolutePath()));
179.     }
180.     return true;
181.   } 
182.   else {
183.     return false;
184.   }
185. }
186. 
     
187. class ModificationDateCompare implements Comparator<File> {
188.     public int compare(File f1, File f2) {
189.       return Long.valueOf(f1.lastModified()).compareTo(f2.lastModified());    
190.     }
191. }
192. 
     
193. FilenameFilter jpgFilter = new FilenameFilter() {
194.   boolean accept(File dir, String name) {
195.     return name.toLowerCase().endsWith(".gif");
196.   }
197. };
 

and the Cover Class:

2. /**
3.  Quick Cover Flow in Processing
4.  by Adrià Navarro http://adrianavarro.net 
5.  USING: 3D (openGL), events (controlp5) and animation (ani)
6.  TODO: image resize, background image loading
7.  */
8. 
   
9. class Cover {
10.   PVector position;
11.   float rotationY;
12.   int transparency;
13.   //PImage img;
14. Gif img;
15. 
    
16. 
    
17.   Cover( String name ) {
18.     this.position = new PVector(0.0, 0.0, 0.0);
19.     this.rotationY = 0.0;
20.     this.transparency = 255;
21.    // this.img = loadImage(name);  /* original working line */ 
22. 
    
24.  img = new Gif(this, name);
25. img.loop();    
26.  img.play();
27.   }
28. 
    
29.   public void drawCover() {
30. 
    
31.     pushMatrix();
32.     translate(position.x, position.y, position.z);
33.     rotateY(rotationY);
34. 
    
35.     // Main quad
36.     noTint();
37.     beginShape();
38.       textureMode(NORMAL);
39.       texture(img);
40.       vertex(-100, -100, 0, 0, 0);
41.       vertex(100, -100, 0, 1, 0);
42.       vertex(100, 100, 0, 1, 1);
43.       vertex(-100, 100, 0, 0, 1);
44.     endShape();
45. 
    
46.     // Reflection
47.     tint(50);
48.     beginShape();
49.       textureMode(NORMAL);
50.       texture(img);
51.       vertex(-100, 100, 0, 0, 1);
52.       vertex(100, 100, 0, 1, 1);
53.       vertex(100, 300, 0, 1, 0);
54.       vertex(-100, 300, 0, 0, 0);
55.     endShape();
56. 
    
57.     noTint();
58.     popMatrix();
59.   }
60. 
    
61.   // Function to call if images are not square
62.   // Not being used at the moment, might need some tweaking
63.   public void resizeImage(PImage img) {
64.     float ratio = 0.0;
65.     int newWidth = 0;
66.     int newHeight = 0;
67. 
    
68.     ratio = (float)img.width / (float)img.height;
69. 
    
70.     if( ratio > 1 ) {   // img is wider than tall
71.       newWidth = 255;
72.       newHeight = (int) (255.0/ratio);
73.     }
74.     else {              // img is taller than wide
75.       newHeight = 255;
76.       newHeight = (int)(255.0*ratio);
77.     }
78.     println ("width: " + newWidth + "height: " + newHeight + "ratio: " + ratio);
79.     img.resize(newWidth,newHeight);
80.   }
81. }

1. 
   
2. String[] imgUrls= loadStrings("/users/me/Desktop/myFolderofFiles");
3. PImage[] images = new PImage[imgUrls.length];
4. for(int i = 0; i<imgUrls.length;i++){
5.       images[i] = loadImage(imgUrls[i]);

2. import vialab.SMT.*;
3. void setup(){
4.   size(400,400,P3D);
5.   SMT.init(this, TouchSource.MULTIPLE);
6. }
7. void draw(){
8.   background(125);
9. }

2. import vialab.SMT.*;
3. 
   
4. 
   
5. final float MAX_ANGLE = radians(70);  // ジャケットの最大傾斜角
6. final float interval = 500;           // 間隔
7. final int   offsetZ  = 400;           // Z方向の移動分
8. final int   bgColor  = color(255, 255, 255);
9. 
   
10. Photo[] p;
11. 
    
12. double offsetX;;
13. 
    
14. 
    
15. void setup() {
16.   size(400, 400, P3D);
17.   SMT.init(this, TouchSource.MULTIPLE);
18. //SMT.add(new ButtonZone("TestButton",100,100,200,200,"Button Text"));
19.   
20.   
21.    p = new Photo[3];
22.   for(int i = 0; i < p.length; i++) {
23.     p[i] = new Photo("/Users/danieljaybertner/Documents/Processing/Clients/quin photobooth/Quin_Photobooth_MAIN/Quin_Photobooth4/data/cute" + i + ".jpg");
24.     p[i].nX = (i - p.length / 2) * interval;
25.   }
26. 
    
27. }
28. void draw() {
29.   background(79, 129, 189);
30.   
31.    camera(0, 0, 1200, 0, 0, 0, 0, 1, 0);
32.   background(bgColor);
33.   
34.   double minX = 9999;
35.   for(int i = 0; i < p.length; i++) { 
36.     p[i].update();
37.     if(abs((float)p[i].nX) < abs((float)minX)) minX = p[i].nX;
38.   }
39.  
40.      
41. // double offsetX;
42.   if(mousePressed) offsetX = 6*(mouseX - pmouseX);
43.   else offsetX = -minX * 0.1;
44.   for(int i = 0; i < p.length; i++) { 
45.     p[i].nX += offsetX;
46.     
47.     
48. }
49. 
    
50. }
51. 
    
52. 
    
53. //////////////////////////////
54. class Photo {
55.   int width  = 640;
56.   int height = 480/2;
57.   
58.   double x;
59.   double z;
60.   private double angle;
61.   double nX;
62.   private double rate = 4.0;
63.   
64.   PImage img;
65.   PImage shadowImg;
66.   
67.   Photo(String fileName) {
68.     img  = loadImage(fileName);
69.     if(img == null) {
70.       img = createImage(128, 128, RGB);
71.       for(int i = 0; i < img.pixels.length; i++) {
72.         img.pixels[i] = 0xFFFFFFFF;
73.       }
74.     }
75.     shadowImg = createImage(img.width, img.height/2, RGB);
76.     
77.  
78.     float a = 100;
79.     float dA = - (float)0xFF / img.height;
80.     for(int iy = 0; iy < shadowImg.height; iy++) {
81.       for(int ix = 0; ix < shadowImg.width; ix++) {
82.         if( a < 0 ) a = 0;
83.         int i = iy * shadowImg.width + ix;
84.         int c = img.pixels[(img.height - iy - 1)*img.width + ix];
85.         
86.         int fg = c;
87.         int fR = (0x00FF0000 & fg) >>> 16; 
88.         int fG = (0x0000FF00 & fg) >>> 8;
89.         int fB =  0x000000FF & fg;
90.         
91.         int bR = (0x00FF0000 & bgColor) >>> 16;
92.         int bG = (0x0000FF00 & bgColor) >>> 8;
93.         int bB =  0x000000FF & bgColor;
94.         
95.         int rR = (fR * (int)a + bR * (int)(0xFF - a)) >>> 8;
96.         int rG = (fG * (int)a + bG * (int)(0xFF - a)) >>> 8;
97.         int rB = (fB * (int)a + bB * (int)(0xFF - a)) >>> 8;
98.         
99.         shadowImg.pixels[i] = 0xFF000000 | (rR << 16) | (rG << 8) | rB;
100.       }
101.       a += dA;
102.     }
103.   }
104.   
105.   void update() {
106.     z = 0;
107.     angle = MAX_ANGLE;
108.     if(nX < 0) angle = -angle;
109.     noStroke();
110.     fill(255);
111.     
112.     if(abs((float)x) <= interval + 0.1) {
113.       x = nX;
114.       angle = MAX_ANGLE * x / interval;
115.       z = offsetZ * (interval - abs((float)nX))/interval;
116.     } else {
117.       x = nX;
118.       double offset = interval;
119.       if(nX < 0) offset = -offset;
120.       x -= offset;
121.       x /= rate;
122.       x += offset;
123.     }
124.     
125.     pushMatrix();
126.     translate((float)x, 0, (float)z);
127.     rotateY(-(float)angle);
128.     
129.   
130.     int   n     = 20; 
131.     float dW    = (float)this.width / n;
132.     float dTexW = (float)img.width  / n;
133.     
134.     lights();
135.     beginShape(QUAD_STRIP);
136.     texture(img);
137.     for(int i = 0; i <= n; i++) {
138.       vertex(-this.width / 2.0 + i*dW, -this.height / 2.0, i*dTexW, 0);
139.       vertex(-this.width / 2.0 + i*dW,  this.height / 2.0, i*dTexW, img.height);
140.     }
141.     endShape();
142.     
143.   
144.     noLights();
145.     beginShape(QUAD_STRIP);
146.     texture(shadowImg);
147.     for(int i = 0; i <= n; i++) {
148.       vertex(-this.width / 2.0 + i*dW, this.height / 2.0, i*dTexW, 0);
149.       vertex(-this.width / 2.0 + i*dW, this.height * 3.0 / 2.0, i*dTexW, shadowImg.height);
150.     }    
151.     endShape();
152.     
153.     popMatrix();
154.   }
155. }

2. <?xml version="1.0" encoding="utf-8"?>
3. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
4.     package="com.google.example.ads.xml"
5.     android:versionCode="1"
6.     android:versionName="1.0">
7.     <uses-sdk android:minSdkVersion="3" />
8.     <uses-sdk android:targetSdkVersion="15" />
9.     
10.     <application android:icon="@drawable/icon" android:label="@string/app_name">
11.         <activity android:name=".BannerSample"
12.             android:label="@string/app_name">
13.             <intent-filter>
14.                 <action android:name="android.intent.action.MAIN" />
15.                 <category android:name="android.intent.category.LAUNCHER" />
16.             </intent-filter>
17.         </activity>
18.         
19.         <activity android:name="com.google.ads.AdActivity"
20.         android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|uiMode|screenSize|smallestScreenSize"/>
21.     </application>
22.     
23.     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
24.     <uses-permission android:name="android.permission.INTERNET"/>
25. </manifest>

2. int iDatum;
3. int counter;
4. void setup() {
5. 
   
6.   //choose a point 5,000 milliseconds in the future  
7.   iDatum=millis()+1000;
8.    timeSinceLastLetter = millis();
9.   ellipse(width/2, height/2, 10, 10);
10. }
11. 
    
12. void draw() {
13. 
    
14. 
    
15.   //is it now time?
16.   if (millis()>=iDatum) {
17.     ellipse(random(width), random(height), 10, 10);
18.     //choose another point 5 seconds hence...   
19.     iDatum=millis() + 1000;
20. counter = counter+1;
21. 
    
22.   }
23.   

1. static class ID_CHECK{
     
   public static int[] numbers = new int[2];
   
   
   
   
    public static int i = 0;
   // " id" is the incoming/changes value
   
   
   numbers[i] = hand_id;  //hand_id is the value comparing. the values change. 
   i = i + 1;
   
   
   if (i == 1) {
      int ID1 = numbers[0];
      int ID2 = numbers[1];
      println(ID1 + "..." + ID2 );
   }
   
   

2. import com.onformative.leap.LeapMotionP5;
3. import com.leapmotion.leap.Finger;
4. 
   
5. LeapMotionP5 leap;
6. 
   
7. 
   
8. //euclidean distance
9. 
   
10. 
    
11. public void setup() {
12.   size(500, 500);
13.   leap = new LeapMotionP5(this);
14. }
15. 
    
16. public void draw() {
17.   background(0);
18.   fill(255);
19.   for (Finger finger : leap.getFingerList()) {
20.     PVector fingerPos = leap.getTip(finger);
21.     ellipse(fingerPos.x, fingerPos.y, 10, 10);
22.     
23.     
24.    
25.     
26.       
27.   }
28. }
29. 
    
30. public void stop() {
31.   leap.stop();
32. }

2. import processing.serial.*;
3. PImage imgHome;
4. PImage imgMil;
5. PImage imgCiv;
6. import cc.arduino.*;
7. 
   
8. Arduino arduino;
9. 
   
10. 
    
11. int button8=8;
12. int button7=7;
13. int button6=6;
14. //this reads button states
15. int state=0;
16. int state2=0;
17. int state3 =0;
18. 
    
19. int Width = 1920;
20. int Height  = 1080;
21. 
    
22. 
    
23. 
    
24. 
    
25. void setup() {
26.   size(Width,Height); //this was size requested for screen
27. 
    
28. imgHome = loadImage("Home.jpg");
29. 
    
30. imgMil = loadImage("Military.jpg"); 
31. 
    
32.   
33. imgCiv = loadImage("Civilian.jpg"); 
34. 
    
35. //size (displayWidth,displayHeight); //this adjusts toyour monitor
36. 
    
37. 
    
38.   arduino = new Arduino(this, Arduino.list()[0], 57600);
39. 
    
40. arduino.pinMode(button8, Arduino.INPUT);
41. arduino.pinMode(button7, Arduino.INPUT);
42. arduino.pinMode(button6, Arduino.INPUT);
43. 
    
44. }
45. 
    
46. void draw() {
47.   state=arduino.digitalRead(button8);
48.     state2=arduino.digitalRead(button7);
49.   //println(state);  //reads button states in serial monitor
50.  //println(state2);
51.   
52.   
53.   switch(state){
54. //compare states and trigger images
55. case 1:
56. 
    
57. 
    
58.  image(imgHome, 0,0);
59.  
60.  case 0:
61.   image(imgHome, 0,0);
62.   break;
63. 
    
64.   
65. }
66. 
    
67. switch(state2){
68. case 1:
69.      
70. image(imgMil, 0,0); 
71. 
    
72. case 0:
73. image(imgMil, 0,0); 
74. break;
75. 
    
76. }
77. 
    
78.  if (state==Arduino.LOW && state2==Arduino.LOW){
79.   
80. image(imgCiv, 0,0);
81. 
    
82. }
83. 
    
84. 
    
85. }

2. /*
3.     TUIO processing demo - part of the reacTIVision project
4.     http://reactivision.sourceforge.net/
5. 
   
6.     Copyright (c) 2005-2009 Martin Kaltenbrunner <mkalten@iua.upf.edu>
7. 
   
8.     This program is free software; you can redistribute it and/or modify
9.     it under the terms of the GNU General Public License as published by
10.     the Free Software Foundation; either version 2 of the License, or
11.     (at your option) any later version.
12. 
    
13.     This program is distributed in the hope that it will be useful,
14.     but WITHOUT ANY WARRANTY; without even the implied warranty of
15.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16.     GNU General Public License for more details.
17. 
    
18.     You should have received a copy of the GNU General Public License
19.     along with this program; if not, write to the Free Software
20.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21. */
22. 
    
23. // we need to import the TUIO library
24. // and declare a TuioProcessing client variable
25. import TUIO.*;
26. TuioProcessing tuioClient;
27. 
    
28. // these are some helper variables which are used
29. // to create scalable graphical feedback
30. float cursor_size = 15;
31. float object_size = 60;
32. float table_size = 760;
33. float scale_factor = 1;
34. PFont font;
35.  ArrayList history = new ArrayList();
36. 
    
37. float distthresh=30;
38. 
    
39. 
    
40. void setup()
41. {
42.   //size(screen.width,screen.height);
43.   size(640,480);
44.   noStroke();
45.   fill(0);
46.   
47.   loop();
48.   frameRate(30);
49.   //noLoop();
50.   
51.   hint(ENABLE_NATIVE_FONTS);
52.   font = createFont("Arial", 18);
53.   scale_factor = height/table_size;
54.   
55.   // we create an instance of the TuioProcessing client
56.   // since we add "this" class as an argument the TuioProcessing class expects
57.   // an implementation of the TUIO callback methods (see below)
58.   tuioClient  = new TuioProcessing(this);
59. }
60. 
    
61. // within the draw method we retrieve a Vector (List) of TuioObject and TuioCursor (polling)
62. // from the TuioProcessing client and then loop over both lists to draw the graphical feedback.
63. void draw()
64. {
65.   background(0);
66.   textFont(font,18*scale_factor);
67.   float obj_size = object_size*scale_factor; 
68.   float cur_size = cursor_size*scale_factor; 
69.    
70.   Vector tuioObjectList = tuioClient.getTuioObjects();
71.   for (int i=0;i<tuioObjectList.size();i++) {
72.      TuioObject tobj = (TuioObject)tuioObjectList.elementAt(i);
73.      stroke(255);
74.      strokeWeight(10);
75.      fill(255);
76.      pushMatrix();
77.      translate(tobj.getScreenX(width),tobj.getScreenY(height));
78.      rotate(tobj.getAngle());
79.      rect(-obj_size/2,-obj_size/2,obj_size,obj_size);
80.      popMatrix();
81.      fill(255);
82.      text(""+tobj.getSymbolID(), tobj.getScreenX(width), tobj.getScreenY(height));
83.    }
84.    
85.    Vector tuioCursorList = tuioClient.getTuioCursors();
86.    for (int i=0;i<tuioCursorList.size();i++) {
87.       TuioCursor tcur = (TuioCursor)tuioCursorList.elementAt(i);
88.       Vector pointList = tcur.getPath();
89.       
90.       if (pointList.size()>0) {
91.         stroke(255);
92.         TuioPoint start_point = (TuioPoint)pointList.firstElement();;
93.         for (int j=0;j<pointList.size();j++) {
94.            TuioPoint end_point = (TuioPoint)pointList.elementAt(j);
95.           // line(start_point.getScreenX(width),start_point.getScreenY(height),end_point.getScreenX(width),end_point.getScreenY(height));
96.            start_point = end_point;
97.         
98.         
99. /*  THIS IS MY ADDITION TO THE ORIGINAL TuioDemo Sketch *//////////////////////////////    
100.         
101.   PVector d = new PVector(start_point.getScreenX(width),end_point.getScreenY(height),cur_size);
102.   history.add(0,d);
103.    
104.   for (int p=0; p<history.size(); p++){
105.     PVector v = (PVector) history.get(p);
106.     float joinchance = p/history.size() + d.dist(v)/distthresh;
107.   
108.     if (joinchance < random(0.4))  line(d.x,d.y,v.x,v.y);
109.     smooth();
110.   ///////////////////////////////////////////////////////////////////////////////////////////  
111.   }
112.         } 
113.         stroke(192,192,192);
114.         fill(192,192,192);
115.         ellipse( tcur.getScreenX(width), tcur.getScreenY(height),cur_size,cur_size);
116.         fill(0);
117.         text(""+ tcur.getCursorID(),  tcur.getScreenX(width)-5,  tcur.getScreenY(height)+5);
118.       }
119.    }
120.    
121. }
122. 
     
123. 
     
124. // these callback methods are called whenever a TUIO event occurs
125. 
     
126. // called when an object is added to the scene
127. void addTuioObject(TuioObject tobj) {
128.   println("add object "+tobj.getSymbolID()+" ("+tobj.getSessionID()+") "+tobj.getX()+" "+tobj.getY()+" "+tobj.getAngle());
129. }
130. 
     
131. // called when an object is removed from the scene
132. void removeTuioObject(TuioObject tobj) {
133.   println("remove object "+tobj.getSymbolID()+" ("+tobj.getSessionID()+")");
134. }
135. 
     
136. // called when an object is moved
137. void updateTuioObject (TuioObject tobj) {
138.   println("update object "+tobj.getSymbolID()+" ("+tobj.getSessionID()+") "+tobj.getX()+" "+tobj.getY()+" "+tobj.getAngle()
139.           +" "+tobj.getMotionSpeed()+" "+tobj.getRotationSpeed()+" "+tobj.getMotionAccel()+" "+tobj.getRotationAccel());
140. }
141. 
     
142. // called when a cursor is added to the scene
143. void addTuioCursor(TuioCursor tcur) {
144.   println("add cursor "+tcur.getCursorID()+" ("+tcur.getSessionID()+ ") " +tcur.getX()+" "+tcur.getY());
145. }
146. 
     
147. // called when a cursor is moved
148. void updateTuioCursor (TuioCursor tcur) {
149.   println("update cursor "+tcur.getCursorID()+" ("+tcur.getSessionID()+ ") " +tcur.getX()+" "+tcur.getY()
150.           +" "+tcur.getMotionSpeed()+" "+tcur.getMotionAccel());
151. }
152. 
     
153. // called when a cursor is removed from the scene
154. void removeTuioCursor(TuioCursor tcur) {
155.   println("remove cursor "+tcur.getCursorID()+" ("+tcur.getSessionID()+")");
156. }
157. 
     
158. // called after each message bundle
159. // representing the end of an image frame
160. void refresh(TuioTime bundleTime) { 
161.   redraw();
162. }

2.  ArrayList history = new ArrayList();
3. 
   
4. float distthresh=30;
5. 
   
6. void setup(){
7.   size(400,400);
8.   background(255);
9.  
10. }
11. 
    
12. void draw(){
13.   stroke(10);
14.   
15.  //strokeWeight(2);
16.   PVector d = new PVector(mouseX,mouseY,0);
17.   history.add(0,d);
18.    
19.   for (int p=0; p<history.size(); p++){
20.     PVector v = (PVector) history.get(p);
21.     float joinchance = p/history.size() + d.dist(v)/distthresh;
22.   
23.     if (joinchance < random(0.4))  line(d.x,d.y,v.x,v.y);
24.     smooth();
25.   }
26.   
27. }

2. import blobDetection.*;
3. 
   
4. BlobDetection theBlobDetection;
5. PGraphics img;
6. 
   
7. // ==================================================
8. // setup()
9. // ==================================================
10. void setup()
11. {
12.   // Works with Processing 1.5
13.   // img = createGraphics(640, 480,P2D);
14. 
    
15.   // Works with Processing 2.0b3
16.   img = createGraphics(640, 480);
17. 
    
18.   img.beginDraw();
19.   img.background(255);
20.   img.noStroke();
21.   img.fill(0);
22.   for (int i=0;i<20;i++) {
23.     float r = random(50);
24.     img.ellipse(random(img.width), random(img.height), r, r);
25.   }
26.   img.endDraw();
27. 
    
28.   theBlobDetection = new BlobDetection(img.width, img.height);
29.   theBlobDetection.setPosDiscrimination(false);
30.   theBlobDetection.setThreshold(0.38f);
31.   theBlobDetection.computeBlobs(img.pixels);
32. 
    
33.   // Size of applet
34.   size(img.width, img.height);
35. }
36. 
    
37. // ==================================================
38. // draw()
39. // ==================================================
40. void draw()
41. {
42.   image(img, 0, 0, width, height);
43.   drawBlobsAndEdges(true, true);
44. }
45. 
    
46. // ==================================================
47. // drawBlobsAndEdges()
48. // ==================================================
49. void drawBlobsAndEdges(boolean drawBlobs, boolean drawEdges)
50. {
51.   noFill();
52.   Blob b;
53.   EdgeVertex eA, eB;
54.   for (int n=0 ; n<theBlobDetection.getBlobNb() ; n++)
55.   {
56.     b=theBlobDetection.getBlob(n);
57.     if (b!=null)
58.     {
59.       // Edges
60.       if (drawEdges)
61.       {
62.         strokeWeight(2);
63.         stroke(0, 255, 0);
64.         for (int m=0;m<b.getEdgeNb();m++)
65.         {
66.           eA = b.getEdgeVertexA(m);
67.           eB = b.getEdgeVertexB(m);
68.           if (eA !=null && eB !=null)
69.             line(
70.             eA.x*width, eA.y*height, 
71.             eB.x*width, eB.y*height
72.               );
73.         }
74.       }
75. 
    
76.       // Blobs
77.       if (drawBlobs)
78.       {
79.         strokeWeight(1);
80.         stroke(255, 0, 0);
81.         rect(
82.         b.xMin*width, b.yMin*height, 
83.         b.w*width, b.h*height
84.           );
85.       }
86.     }
87.   }
88. }

1. public enum states { STATE_1, STATE_2, STATE_3, STATE_4, STATE_5, STATE_6, MAX_STATES };
2. 
   
3. states state = new states;

1. switch (state){
2. 
   
3. case STATE_1 : 
4. // if this does that, do something
5. }
6. state = STATE_2;
7. break;
8. 
   
9. case STATE_2: 
10. // if this does that, do something
11. }
12. state = STATE_3;
13. break;
14. //etc etc

                   

                    
loadPixels(); 
                    
// Loop through every pixel column
                    
for (int x = 0; x < width; x++) {
                    
 // Loop through every pixel row
                    
 for (int y = 0; y < height; y++) {
                    
 // Use the formula to find the 1D location
                    
 int loc = x + y * width;
                    
 if (x % 2 == 0) { // If we are an even column
                    
 pixels[loc] = color(255);
                    
 } else { // If we are an odd column
                    
 pixels[loc] = color(0);
                    
 }
                    
 }
                    
}
                    
updatePixels()
                   
                   

                    I was thinking of this, but just unclear on how to just get a general average of all
                   

2. import org.openkinect.*;
3. import org.openkinect.processing.*;
4. 
   
5. Kinect kinect;
6. boolean depth = true;
7. 
   
8. 
   
9. float deg = 15; // Start at 15 degrees
10. 
    
11.  
12.   
13. void setup() {
14.   size(800,600);
15.   kinect = new Kinect(this);
16.   kinect.start();
17.   kinect.enableDepth(depth);
18.  
19.   
20. }
21. 
    
22. 
    
23. void draw() {
24.   background(0);
25. 
    
26.   
27. image(kinect.getDepthImage(),800,800);
28.   fill(255);
29.   
30.  
31.     kinect.enableDepth(depth);
32. PImage img = kinect.getDepthImage();
33.   image(img,0,0);
34.   
35. ///////check to see pixel color for depth //////////////////
36.   color c = get(mouseX, mouseY);
37. fill(c);
38. println(c);
39. noStroke();
40. rect(width/2, height/2, 50, 50);
41. }
42. ////////////////////////////////////////////////////////////
43. 
    
44. void stop() {
45.   kinect.quit();
46.   super.stop();
47. }

2. /**
3.  * Load and Display 
4.  * 
5.  * Images can be loaded and displayed to the screen at their actual size
6.  * or any other size. 
7.  */
8.  
9. // The next line is needed if running in JavaScript Mode with Processing.js
10. /* @pjs preload="moonwalk.jpg"; */ 
11. 
    
12. 
    
13. PImage img; 
14. PImage img2; 
15. PImage img3;  // Declare variable "a" of type PImage
16. 
    
17. 
    
18. void setup() {
19.   size(640, 360);
20. 
    
21.   // The image file must be in the data folder of the current sketch 
22.   // to load successfully
23.   img = loadImage("infographic1.png");
24.   img2 = loadImage("infographic2.png");
25.   img3 = loadImage("infographic3.png");  // Load the image into the program  
26. }
27. 
    
28. void draw() {
29.   // Displays the image at its actual size at point (0,0)
30.   
31.  image(img, 0, 0, 640, 400);
32.   line(mouseX, 20, mouseX, 80);
33.   println(mouseX);
34.   
35.  while(img ==img && mouseX > 500){
36.     
37.  image(img2, 0, 0, 640, 400);
38.  break;
39.   }
40.     while(img2 ==img2 && mouseX > 500){
41.     
42.  image(img3, 0, 0, 640, 400);
43.  break;
44.   }
45. 
    
46.   
47.   
48. }

2.   if ( myPort.available() > 0) {  // If data is available,
3.     val = myPort.read();         // read it and store it in val
4.   }
5.               // Set background to white
6.   if (val == 1) {              // arduino is sending a "1" when a sensor argument is met. 
7.    groove.play(); //the song plays entirely. the argument does not interfere if its met.
8. 
   
9. if (x < 18.0 && val ==1){  //x is measuring the length of song, float numbers 1-20 (20 is end). not working.
10.   groove.play(); 

2. // Daniel Shiffman
3. // Kinect Point Cloud example
4. // http://www.shiffman.net
5. // https://github.com/shiffman/libfreenect/tree/master/wrappers/java/processing
6. 
   
7. import org.openkinect.*;
8. import org.openkinect.processing.*;
9. 
   
10. // Kinect Library object
11. Kinect kinect;
12. 
    
13. boolean depth = true;
14. 
    
15. // We'll use a lookup table so that we don't have to repeat the math over and over
16. 
    
17. void setup() {
18. 
    
19.   kinect = new Kinect(this);
20.   kinect.start();
21.   kinect.enableDepth(depth);
22.  
23.  
24.   // Lookup table for all possible depth values (0 - 2047)
25.   
26.   }
27. 
    
28. 
    
29. void draw() {
30.   background(0);
31.   
32.  int[] depthraw = kinect.getRawDepth();
33.  println(depthraw);
34. }