2. // Starting angle
3. float theta = 0.0;
4. 
   
5. void setup() {
6.   size(500, 300);
7.   smooth();
8. }
9. 
   
10. void draw() {
11.   background(255);
12. 
    
13.   // Increment theta (try different values for " angular velocity " here)
14.   theta += 0.02;
15.   noStroke();
16.   //stroke(1);
17.   fill(0);
18.   //noFill();
19.   float x = theta;
20.     
21.   // A for loop is used to draw all the points along a sine wave (scaled to the pixel dimension of the window).
22.   for (int i = 0; i <= width; i++) {
23.     float y = sin(x) * height/4;
24.     
25.     beginShape();
26.     
27.     ellipse(i*10, y + height/2+(1*10), 5, 5);
28.     ellipse(i*10, y + height/2+(2*10), 5, 5);
29.     ellipse(i*10, y + height/2+(3*10), 5, 5);
30.     
31.     x += 0.2;
32.     endShape();
33.   }
34. }

2. PVector location;  // Location of shape
3. PVector velocity;  // Velocity of shape
4. PVector gravity;   // Gravity acts at the shape's acceleration
5. PFont font;
6. 
   
7. PGraphics ball, pg;
8. 
   
9. void setup() {
10.   size(400, 400);
11.   smooth();
12.   location = new PVector(100, 100);
13.   velocity = new PVector(1.5, 2.1);
14.   gravity = new PVector(0, 0.2);
15.   font = createFont("ArialMT-48.vlw", 80);
16.   pg = createGraphics(400, 400);
17.   ball = createGraphics(400, 400);
18. }
19. 
    
20. void draw() {
21.   background(0);
22. 
    
23.   pg.beginDraw();
24.   pg.smooth();
25.   pg.textFont(font);
26.   pg.fill(255,0,0);
27.   pg.text("TESTING", 30, 150, pg.width, pg.height);
28.   pg.endDraw();
29. 
    
30.   location.add(velocity);
31.   velocity.add(gravity);
32.   if ((location.x > width) || (location.x < 0)) {
33.     velocity.x = velocity.x * -1;
34.   }
35.   if (location.y > height) {
36.     velocity.y = velocity.y * -0.95; 
37.     location.y = height;
38.   }
39. 
    
40.   ball.beginDraw();
41.   ball.noStroke();
42.   ball.background(0);
43.   ball.fill(255);
44.   ball.ellipse(location.x, location.y, 100, 100);
45.   ball.endDraw();
46.   
47.   ball.filter(GRAY);
48.   ball.mask(pg);
49.   
50.   image(pg, 0, 0);
51. }

2. FloatTable data; 
3. Plot[] sensorData; 
4. 
   
5. String fileName;
6. color[] colorPlot = {
7.   #5679C1, #950095, #F79432
8. };
9. 
   
10. float valueX;
11. int currentColumn = 0; 
12. int columnCount; 
13. //String path = "/Users/Desktop/DataFeedFiles/dataFolder/";
14. String[] filenames;
15. ArrayList<String> fileList;
16. String selectedFile = "1.csv";
17. int numberOfPlots = 3;
18. 
    
19. void setup() {
20.   size(800, 480);
21.   loadData();
22. }
23. 
    
24. void draw () { 
25.   background(200); 
26.   println  (selectedFile);
27.   
28.   //Draw points according to the number of columns that are in the file. Each column 
29.   //has one number / point
30.   for (int i=0; i < columnCount; i++) {
31.     sensorData[i].drawDataPoint();
32.   }
33. }
34. 
    
35. void loadData(){
36.   File file = new File(selectedFile);
37.   data = new FloatTable(selectedFile);   
38.   columnCount = data.getColumnCount();
39.   sensorData = new Plot[numberOfPlots];
40.   for (int i=0; i<numberOfPlots; i++) { 
41.     sensorData[i] = new Plot ();
42.   } 
43. }
44. 
    
45. void keyPressed() {
46.   if (key == 'A' || key == 'a') {
47.     selectedFile = "1.csv";
48.     loadData();
49.   }
50.   if (key == 'S' || key == 's') {
51.     selectedFile = "2.csv";
52.     loadData();
53.   }
54. }
55. 
    
56. class FloatTable {
57.   //Based on Ben Fry's class
58.   int rowCount;
59.   int columnCount;
60.   int columnCountSensors;
61. 
    
62.   float[][] data;
63.   String[] rowNames;
64.   String[] columnNames;
65.   String[] columns;
66. 
    
67.   FloatTable(String filename) {
68.     String[] rows = loadStrings(filename);
69.     columns = split(rows[0], ','); //Get columns and set the array
70.     columnNames = subset(columns, 0); // Ignore first columns, get only sensor data
71.     columnCount = columnNames.length; //Get number of columns, i.e. sensor data
72.     rowNames = new String[rows.length-1];
73. 
    
74.     data = new float[rows.length-1][];
75. 
    
76.     for (int i = 1; i < rows.length; i++) {
77.       String[] pieces = split(rows[i], ',');
78.       rowNames[rowCount] = pieces[0]; //Get all the values from column 3,  i.e. Minute
79.       data[rowCount] = parseFloat(subset(pieces, 1)); //getColumn except row 1 - header
80.       rowCount++;
81.     }
82.     data = (float[][]) subset(data, 0, rowCount);
83.   }
84. 
    
85.   int getRowCount() {
86.     return rowCount;
87.   }
88. 
    
89.   String getRowName(int rowIndex) {
90.     return rowNames[rowIndex];
91.   }
92. 
    
93.   String[] getRowNames() {
94.     return rowNames;
95.   }
96. 
    
97.   int getRowIndex(String name) {
98.     for (int i = 0; i < rowCount; i++) {
99.       if (rowNames[i].equals(name)) {
100.         return i;
101.       }
102.     }
103.     return -1;
104.   }
105. 
     
106.   int getAllColumnCount() {
107.     return columns.length;
108.   }
109. 
     
110.   int getColumnCount() {
111.     return columnCount;
112.   }
113. 
     
114.   int getColumnCountSensors() {
115.     columnCountSensors = columnCount;
116.     return columnCountSensors;
117.   }
118. 
     
119.   String getColumnName(int colIndex) {
120.     return columnNames[colIndex];
121.   }
122. 
     
123.   String[] getColumnNames() {
124.     return columnNames;
125.   }
126. 
     
127.   float getFloat(int rowIndex, int col) {
128.     if ((rowIndex < 0) || (rowIndex >= data.length)) {
129.       throw new RuntimeException("There is no row " + rowIndex);
130.     }
131.     if ((col < 0) || (col >= data[rowIndex].length)) {
132.       throw new RuntimeException("Row " + rowIndex + " does not have a column " + col);
133.     }
134.     return data[rowIndex][col];
135.   }
136. 
     
137.   boolean isValid(int row, int col) {
138.     if (row < 0) return false;
139.     if (row >= rowCount) return false;
140.     if (col >= columnCount) return false;
141.     if (col >= data[row].length) return false;
142.     if (col < 0) return false;
143.     return !Float.isNaN(data[row][col]);
144.   }
145.   float getTableMin(int colNum) {
146.     float m = Float.MAX_VALUE;
147.     for (int row = 0; row < rowCount; row++) {
148.       //for (int col = 0; col < columnCount; col++) {
149.       //if (isValid(row, col)) {
150.       if (data[row][colNum] < m) {
151.         m = data[row][colNum];
152.         //}
153.         //}
154.       }
155.     }
156.     return m;
157.   }
158.   float getTableMax(int colNum) {
159.     float m = -Float.MAX_VALUE;
160.     for (int row = 0; row < rowCount; row++) {
161.       // for (int col = 0; col < columnCount; col++) {
162.       //if (isValid(row, col)) {
163.       if (data[row][colNum] > m) {
164.         m = data[row][colNum];
165.         //}
166.         //}
167.       }
168.     }
169.     return m;
170.   }
171.   float getColumnMin(int col) {
172.     float m = Float.MAX_VALUE;
173.     for (int i = 0; i < rowCount; i++) {
174.       if (isValid(i, col)) {
175.         if (data[i][col] < m) {
176.           m = data[i][col];
177.         }
178.       }
179.     }
180.     return m;
181.   }
182. 
     
183.   float getColumnMax(int col) {
184.     float m = -Float.MAX_VALUE;
185.     for (int i = 0; i < rowCount; i++) {
186.       if (isValid(i, col)) {
187.         if (data[i][col] > m) {
188.           m = data[i][col];
189.         }
190.       }
191.     }
192.     return m;
193.   }
194. 
     
195.   float getRowMin(int row) {
196.     float m = Float.MAX_VALUE;
197.     for (int i = 0; i < columnCount; i++) {
198.       if (isValid(row, i)) {
199.         if (data[row][i] < m) {
200.           m = data[row][i];
201.         }
202.       }
203.     }
204.     return m;
205.   } 
206. 
     
207.   float getRowMax(int row) {
208.     float m = -Float.MAX_VALUE;
209.     for (int i = 0; i < columnCount; i++) {
210.       if (isValid(row, i)) {
211.         if (data[row][i] > m) {
212.           m = data[row][i];
213.         }
214.       }
215.     }
216.     return m;
217.   }
218. }
219. 
     
220. class Plot {
221.   //Take csv data and create plots
222.   Plot () {
223.   }
224. 
     
225.   void drawDataPoint() {
226.     fill(#5679C1);
227.     //strokeWeight(1);
228.     //stroke(#5679C1);
229.     beginShape( );
230.     for (int i = 0; i < columnCount; i++) { 
231.       float value = data.getFloat(i, 0);
232.       float x = map(i, data.getTableMin(0), data.getTableMax(0), 0, width); 
233.       float y = map(value, data.getTableMin(0), data.getTableMax(0), 0, height);
234.       point(x, y);
235.     }
236.     endShape( );
237.   }
238. }

String[] listFileNames() {

  File file = new File(path);

  if (file.isDirectory()) {  

    String names[] = file.list();

    for (int i=0; i<names.length; i++) {

      if (names[i].toLowerCase().endsWith(".csv")) {

        println(names[i]);

      }

    }

    return names;

  } 

  else {

    return null;

  }

}

1. int fade = 0;

   
   

   void setup(){

     size (400,400); 

   }

   
   

   void draw(){

     fade++;

     fade = constrain(fade, 0, 255);

     println (fade);

   }

   
   

2. import controlP5.*;
3. 
   
4. ControlP5 cp5;
5. int newValue;
6. 
   
7. void setup() {
8.   size(640, 250);
9.   noStroke();
10.   frameRate(30);
11. 
    
12.   cp5 = new ControlP5(this);
13.   cp5.addSlider("slider").setPosition(20, 100).setSize(150, 20).setRange(0, 255).setValue(255);
14. }
15. 
    
16. void draw() {
17.   background(80);
18. }
19. 
    
20. void slider (int theSlider) {
21.   newValue = theSlider;
22.   println(newValue);
23. }

2. InputItem[] inItem = new InputItem[4];
3. OutItem[] outItem = new OutItem[4];
4. int validate1, validate2, validateMouse1, validateMouse2 = 0;
5. float pos1StartX, pos1StartY, pos1EndX, pos1EndY = -999;
6. float pos2StartX, pos2StartY, pos2EndX, pos2EndY = -999;
7. 
   
8. boolean clickedBall1, clickedBall2, selectBall1, connection = false;
9. 
   
10. void setup() {
11.   size(800, 480);
12.   noStroke();
13.   smooth();
14.   for (int i = 0; i < 4; i++) { 
15.     inItem[i] = new InputItem ();
16.     outItem[i] = new OutItem ();
17.   }
18. }
19. 
    
20. void draw() {
21.   background(30);
22.   drawLine();
23.   for (int i = 0; i < 4; i++) {
24.     inItem[i].update();
25.     inItem[i].display();
26.     outItem[i].update();
27.     outItem[i].display();
28.   }
29. }
30. 
    
31. void mouseReleased() {
32.   if (validateMouse1 == 1 && validate2 == 1) { 
33.     connection = true;
34.   }
35.   if (!connection) {
36.     validate1 = 0;
37.     validate2 = 0;
38.     validateMouse1 = 0;
39.     pos1StartX = -999;
40.     pos1StartY = -999;
41.     pos1EndX = -999;
42.     pos1EndY = -999;
43.   }
44. }
45. 
    
46. void drawLine() {
47.   strokeWeight(2);
48.   pos1StartX = -999;
49.   pos1StartY = -999;
50.   pos1EndX = -999;
51.   pos1EndY = -999;
52. 
    
53.   if (inItem[0].mouseOverItem()) validate1 = 1;
54.   for (int i = 0; i < inItem.length; i++) {
55.     if (outItem[i].mouseOverItem()) {
56.       validate2 = 1;
57.     } 
58.     else {
59.       validate2 = 0;
60.     }
61. 
    
62.     if (validate1 == 1 && mousePressed && !connection) {
63.       validateMouse1 = 1;
64.       stroke(255, 255, 0, 255);
65.       pos1StartX = inItem[i].location.x;
66.       pos1StartY = inItem[i].location.y;
67.       pos1EndX = mouseX;
68.       pos1EndY = mouseY;
69.       line(pos1StartX, pos1StartY, pos1EndX, pos1EndY);
70.     } 
71.     else {
72.       stroke(255, 255, 0, 0);
73.       pos1StartX = -999;
74.       pos1StartY = -999;
75.       pos1EndX = -999;
76.       pos1EndY = -999;
77.     }
78. 
    
79.     if (connection) {
80.       validate1 = 0;
81.       validate2 = 0;
82.       pos1StartX = inItem[0].location.x;
83.       pos1StartY = inItem[0].location.y;
84.       pos2EndX = outItem[i].location.x;
85.       pos2EndY = outItem[i].location.y;
86.       stroke(255, 255, 255, 255);
87.       line(pos1StartX, pos1StartY, pos2EndX, pos2EndY);
88.     } 
89.     else {
90.       pos1StartX = -999;
91.       pos1StartY = -999;
92.       pos1EndX = -999;
93.       pos1EndY = -999;
94.       stroke(255, 255, 255, 0);
95.     }
96. 
    
97.     if (connection && outItem[i].mouseOverItem() && mousePressed) {
98.       validate1 = 1;
99.       validate2 = 0;
100.       validateMouse1 = 0;
101.       connection = false;
102.     }
103.   }
104. }
105. 
     
106. class InputItem {
107.   int circleRadius = 50;
108.   PVector location, offsetLoc;
109.   PVector velocity, velocityStart, velocityStop;
110.   color colObject = color ((int) random (50), 0, (int) random (200));
111. 
     
112.   // Constructor
113.   InputItem () {
114.     location = new PVector((int) random(width), (int)random (height));
115.     offsetLoc = new PVector(circleRadius, 0);
116.     velocity = new PVector(random(-0.8, 0.8), random(-0.8, 0.8));
117.     velocityStart = new PVector(random(-0.8, 0.8), random(-0.8, 0.8));  
118.     velocityStop = new PVector(0, 0);
119.   }
120. 
     
121.   void update() {
122.     location.add(velocity);
123.     if (location.x > width-circleRadius) {
124.       velocity.x = velocity.x * -1.;
125.       location.x = width-circleRadius;
126.     }
127.     else if (location.x < circleRadius) {
128.       velocity.x = velocity.x * -1.;
129.       location.x = circleRadius;
130.     }
131. 
     
132.     if (location.y > height-circleRadius) {
133.       velocity.y = velocity.y * -1.;
134.       location.y = height-circleRadius;
135.     }
136.     else if (location.y < circleRadius) {
137.       velocity.y = velocity.y * -1.;
138.       location.y = circleRadius;
139.     }
140.   }
141. 
     
142.   void display() {
143.     fill(colObject);
144.     noStroke();
145.     ellipse(location.x, location.y, circleRadius*1.5, circleRadius*1.5);
146.   }
147. 
     
148.   boolean mouseOverItem() {
149.     float disX = location.x -mouseX;
150.     float disY = location.y - mouseY;
151.     if (sqrt (sq (disX) + sq (disY)) < circleRadius) {
152.       return true;
153.     }
154.     else {
155.       return false;
156.     }
157.   }
158. }
159. 
     
160. class OutItem {
161.   int circleRadius = 50;
162.   PVector location, offsetLoc;
163.   PVector velocity, velocityStart, velocityStop;
164.   color colObject = color (200, (int) random (50), 0);
165. 
     
166.   // Constructor
167.   OutItem () {
168.     location = new PVector((int) random(width), (int)random (height));
169.     offsetLoc = new PVector(circleRadius, 0);
170.     velocity = new PVector(random(-0.8, 0.8), random(-0.8, 0.8));
171.     velocityStart = new PVector(random(-0.8, 0.8), random(-0.8, 0.8));  
172.     velocityStop = new PVector(0, 0);
173.   }
174. 
     
175.   void update() {
176.     location.add(velocity);
177.     if (location.x > width-circleRadius) {
178.       velocity.x = velocity.x * -1.;
179.       location.x = width-circleRadius;
180.     }
181.     else if (location.x < circleRadius) {
182.       velocity.x = velocity.x * -1.;
183.       location.x = circleRadius;
184.     }
185. 
     
186.     if (location.y > height-circleRadius) {
187.       velocity.y = velocity.y * -1.;
188.       location.y = height-circleRadius;
189.     }
190.     else if (location.y < circleRadius) {
191.       velocity.y = velocity.y * -1.;
192.       location.y = circleRadius;
193.     }
194.   }
195. 
     
196.   void display() {
197.     fill(colObject);
198.     noStroke();
199.     ellipse(location.x, location.y, circleRadius*1.5, circleRadius*1.5);
200.   }
201. 
     
202.   boolean mouseOverItem() {
203.     float disX = location.x -mouseX;
204.     float disY = location.y - mouseY;
205.     if (sqrt (sq (disX) + sq (disY)) < circleRadius) {
206.       return true;
207.     }
208.     else {
209.       return false;
210.     }
211.   }
212. }

2. color dotColor = color(192);
3. color dotColorOver = color(255);
4. color dotColorClicked = color(255, 255, 0);
5. 
   
6. // arrays are used to store the dots and to store the lines
7. Dot[] dots = new Dot[5];
8. Line[] lines = new Line[8];
9. 
   
10. // 99 is just a number to indicate that no dot is selected
11. // it cannot be zero, because the first element in the array is zero
12. int selectedDot=99, startDot = 99, endDot = 99;
13. 
    
14. // if a dot is selected draw a line from that dot to the mouse position
15. boolean drawing;
16. boolean solved;
17. 
    
18. void setup() {
19.   size(200, 200);
20.   frameRate(15);
21. 
    
22.   drawing=false;
23.   solved=false;
24. 
    
25.   /* create each dot, the coordinates are random */
26.   dots[0] = new Dot((int) random(width), (int) random(height));
27.   dots[1] = new Dot((int) random(width), (int) random(height));
28.   dots[2] = new Dot((int) random(width), (int) random(height));
29.   dots[3] = new Dot((int) random(width), (int) random(height));
30.   dots[4] = new Dot((int) random(width), (int) random(height));
31. 
    
32.   /* set the color for each dot and draw the dot */
33.   for (int i=0; i<5; i++) {
34.     dots[i].c = dotColor;
35.     dots[i].display(dots[i].c);
36.   }
37. 
    
38.   lines[0] = new Line(0, 1);
39.   lines[1] = new Line(0, 3);
40.   lines[2] = new Line(0, 4);
41.   lines[3] = new Line(1, 2);
42.   lines[4] = new Line(1, 3);
43.   lines[5] = new Line(1, 4);
44.   lines[6] = new Line(2, 3);
45.   lines[7] = new Line(3, 4);
46. }
47. 
    
48. void draw() {
49.   background(205);
50. 
    
51.   /* draw the dots */
52.   for (int i=0; i<5; i++) {
53.     dots[i].display(dots[i].c);
54.   }
55. 
    
56.   /* draw the lines */
57.   for (int i=0; i<8; i++) {
58.     if (lines[i].visible==true) { 
59.       lines[i].display();
60.     }
61.   }
62. 
    
63.   /* draw a line on mouse movement */
64.   if (drawing==true) {     
65.     line(dots[selectedDot].x, dots[selectedDot].y, mouseX, mouseY);
66.   }
67. }
68. 
    
69. void mouseReleased() {
70.   if (selectedDot!=99) {
71.     dots[selectedDot].c=dotColor;
72.   }
73. 
    
74.   /* find out which dot was selected */
75.   drawing=false;  
76.   for (int i=0; i<5; i++) {
77.     if ((dots[i].selected()==true) && (i!=startDot)) {
78.       drawing=true;
79.       dots[i].c=dotColorClicked;
80.       selectedDot=i;
81.       break;
82.     }
83.   }
84. 
    
85.   if (drawing==true) {
86.     if (startDot==99) {
87.       startDot=selectedDot;
88.     } 
89.     else if (endDot==99) {
90.       endDot=selectedDot;
91.       drawLine(startDot, endDot);
92.     }
93.     startDot=selectedDot;
94.     endDot=99;
95.   } 
96.   else {
97.     startDot=99;
98.     endDot=99;
99.   }
100. }
101. 
     
102. void mouseMoved() {
103.   if (solved==false) {
104.     for (int i=0; i<5; i++) {
105.       if (selectedDot==i) {
106.         // do not change on mouseover if the dot is the selected dot
107.       } 
108.       else
109.         if (dots[i].selected()==true) {
110.           dots[i].c=dotColorOver;
111.         } 
112.         else {
113.           dots[i].c=dotColor;
114.         }
115.     }
116.   }
117. }
118. 
     
119. /* mouseDrag is the same as mouseMove */
120. void mouseDragged() {
121.   mouseMoved();
122. }
123. 
     
124. class Dot {
125.   int x; // dot x position
126.   int y; // dot y position
127.   int s; // dot size
128.   color c; // dot color
129.   boolean selected;
130. 
     
131.   Dot(int localX, int localY) {
132.     x = localX;
133.     y = localY;
134.     s = 20;
135.     c = color(192);
136.   }
137. 
     
138.   void display(int dotColor) {
139.     fill(dotColor);
140.     ellipse(x, y, s, s);
141.   }
142. 
     
143.   boolean selected() {
144.     /* this code makes a square over the circle */
145.     /*   if (mouseX >= x-(s/2) && mouseX <= x+(s/2) && 
146.      mouseY >= y-(s/2) && mouseY <= y+(s/2)) {   */
147. 
     
148.     /* code for circle taken from Examples -> Topics -> GUI -> Button */
149. 
     
150.     float disX = x - mouseX;
151.     float disY = y - mouseY;
152. 
     
153.     if (sqrt(sq(disX) + sq(disY)) < s/2 ) {
154.       return true;
155.     } 
156.     else {
157.       return false;
158.     }
159.   }
160. }
161. 
     
162. class Line {
163.   int startX, startY;
164.   int endX, endY;
165.   boolean visible;
166. 
     
167.   Line(int startDot, int endDot) {
168.     startX=dots[startDot].x;
169.     startY=dots[startDot].y;
170.     endX=dots[endDot].x;
171.     endY=dots[endDot].y;
172.     visible=false;
173.   }
174. 
     
175.   void display() {
176.     line(startX, startY, endX, endY);
177.   }
178. }
179. 
     
180. void drawLine(int startDot, int endDot) {
181.   /* set a and b to something different than from 0 to 4 */
182.   int a = 9;
183.   int b = 9;
184. 
     
185.   /* change the order of the selected dots, so that the 
186.    * dot with the lowest number comes first
187.    * then check which line fits to the selected dot combination
188.    */
189.   if (startDot < endDot) {
190.     a = startDot;
191.     b = endDot;
192.   } 
193.   else if (startDot > endDot) {
194.     a = endDot;
195.     b = startDot;
196.   } 
197.   else {
198.     drawing=false;
199.   }
200. 
     
201.   if (drawing==true) {
202.     if ((a==0)&&(b==1)) lines[0].visible=true;
203.     if ((a==0)&&(b==3)) lines[1].visible=true;
204.     if ((a==0)&&(b==4)) lines[2].visible=true;
205.     if ((a==1)&&(b==2)) lines[3].visible=true;
206.     if ((a==1)&&(b==3)) lines[4].visible=true;
207.     if ((a==1)&&(b==4)) lines[5].visible=true;
208.     if ((a==2)&&(b==3)) lines[6].visible=true;
209.     if ((a==3)&&(b==4)) lines[7].visible=true;
210.   }
211. }

2. 
   
3. color one = #ff0000;
4. color two = #00ff00;
5. 
   
6. boolean clicked = false;
7. int count = 0;
8. 
   
9. void setup() {
10.   size(400, 100);
11. }
12. 
    
13. void draw() {
14.   for (int i = 0; i < width; i++) {    
15.     if (clicked) {
16.       count++;
17.       if (count>=100) {
18.         clicked = false;
19.         count = 0;
20.       }
21.     }
22.     float newCount = map(count, 0, 100, 0., 1.);
23.     stroke(lerpColor(one, two, newCount, HSB));
24.     line(i, 0, i, height);
25.   }
26. }
27. 
    
28. void mousePressed() {
29.   clicked = true;
30. }

2. float x, y;
3. float radiusCircle = 100;
4. float[] noises;
5. float noiseVar = 0.00f;
6. float timer = 0.00f;
7. float timerAmount = -100f;
8. 
   
9. void setup() {
10.   size(400, 400);
11.   frameRate(30);
12.   translate(width/2, height/2);
13.   background(60);
14.   smooth();
15.   for (float i = 0; i < 10; i++) {
16.     noises[i] = new float[i];
17.   }
18. }
19. 
    
20. void draw() {
21.   stroke(255);
22.   strokeWeight(5);
23.   timer = timer + timerAmount / frameRate;
24.   for (float i = 0.314; i < 2*PI; i += .314) {
25.     noises[i] = noise((timer+i) * 0.005, (-timer + i) * 0.005, i * 0.005);
26.     x = cos(i) * radiusCircle;
27.     y = sin(i) * radiusCircle;
28.     point(x*noises[i], y*noises[i]);
29.   }
30. }

2. int strength = 200;
3. int ystep = 5;
4. int xstep = 20;
5. 
   
6. void setup() {
7.   size(600, 400);
8.   smooth();
9.   background(0);
10.   frameRate(30);
11. }
12. 
    
13. void draw() {
14.   background(0);
15.   strokeWeight(0.5);
16.   translate(0, height/4);
17.   for (int y = 0; y < strength; y += ystep) {          
18.     beginShape();
19.     for (int x = 0; x <= (width-xstep) + xstep; x += xstep) {
20.       stroke(255);
21.       noFill();
22.       curveVertex(x, y);
23.     }
24.     endShape();
25.   }
26. }

2. float time = 0;
3. 
   
4. void setup() {
5.   size (500, 500);
6. }
7. 
   
8. void draw() {
9.   fill(255, 20);
10.   rect(0, 0, width, height);
11.   background(255);
12. 
    
13.   float x = 0;
14. 
    
15.   while (x <width) {
16.     point (x, height*noise(x/105, time));
17.     x= x + 1;
18.   }
19.   time = time + 0.05;
20. }

2. int textY = 10;
3. int textX = 50;
4. int start = 0;
5. int numLines;
6. int yDist = 15;
7. String[] lines;
8. 
   
9. void setup() {  
10.   size(1024, 768);  
11.   lines = loadStrings("data.txt");  
12.   numLines = height/yDist;
13. }
14. 
    
15. void draw() {  
16.   background(250);
17.   rect(923, 0, width, height);
18.   start = abs(textY/yDist);
19.   for (int i = 0; i < numLines; i++ ) {    
20.     fill(0);
21.     text(lines[i+start], 380, (yDist * i), 1000, 20);
22.   }
23. }