PROCESSING_TEMPLATES

===========================Copy_Paste_Code_2Run===========

The following code should run in a Processsing 2.02 environment

#0 ================================================== 

May need to set path from default

#1 ================================================== 

Open  Processing 

#2 ================================================== 

Open New file

#3 ================================================== 

Copy and Paste code into window and hit run

#4 ================================================== 

Will be needing a code folder later

 =======================Calculate===========

float x;

for                             (int i=0; i <10;  i++)

{ x = float(i)/10;

  println( x); 

}

=================================result===================

0.1

0.2

0.3

...

=======================CreatePwd==============================

int b ;                   

randomSeed(                     58206);                 // seed each time

for                             (int i=0; i <14;  i++)

{ b                          =  int(random(35, 123));

  if                            ( b== 39)  b = 38;

  if                            ( b== 94)  b = 75;

  if                            ( b== 95)  b = 103;

  if                            ( b== 96)  b = 119;

  print(                        char(b ));

}  

=================================result===================      

Yn6u+P3L]ewa#

Tgl-m@9b4p@0I0

fyiDOYVww,Wo)[

X+r-X=k&E%P*kn 

Tgl-m@9b4p@0I0                         

=====================PRINT_ASCII==============================

int x,y,z,w,u,v;

for                          (int i=33; i <53;  i++)

{ x                        = i;                  

  y                        = i+20;

  z                        = i+40;

  w                        = i+60;

  u                        = i+80;

  println(                  "i= "+x+" "+char(x)+"  i= "+y+" "+char(y)+"  i= "+z+" "+char(z)

                         +"  i= "+w+" "+char(w)+"  i= "+u+" "+char(u) );  

}  

=============================result===================

i= 33 !  i= 53 5  i= 73 I  i= 93 ]   i= 113 q

i= 34 "  i= 54 6  i= 74 J  i= 94 ^   i= 114 r

i= 35 #  i= 55 7  i= 75 K  i= 95 _   i= 115 s

i= 36 $  i= 56 8  i= 76 L  i= 96 `   i= 116 t

i= 37 %  i= 57 9  i= 77 M  i= 97 a   i= 117 u

i= 38 &  i= 58 :  i= 78 N  i= 98 b   i= 118 v

i= 39 '  i= 59 ;  i= 79 O  i= 99 c   i= 119 w

i= 40 (  i= 60 <  i= 80 P  i= 100 d  i= 120 x

i= 41 )  i= 61 =  i= 81 Q  i= 101 e  i= 121 y

i= 42 *  i= 62 >  i= 82 R  i= 102 f  i= 122 z

i= 43 +  i= 63 ?  i= 83 S  i= 103 g  i= 123 {

i= 44 ,  i= 64 @  i= 84 T  i= 104 h  i= 124 |

i= 45 -  i= 65 A  i= 85 U  i= 105 i  i= 125 }

i= 46 .  i= 66 B  i= 86 V  i= 106 j  i= 126 ~

i= 47 /  i= 67 C  i= 87 W  i= 107 k  i= 127 

i= 48 0  i= 68 D  i= 88 X  i= 108 l  i= 128 ?

i= 49 1  i= 69 E  i= 89 Y  i= 109 m  i= 129 ?

i= 50 2  i= 70 F  i= 90 Z  i= 110 n  i= 130 ?

i= 51 3  i= 71 G  i= 91 [  i= 111 o  i= 131 ?

i= 52 4  i= 72 H  i= 92 \  i= 112 p  i= 132 ?

=======================Convert==============================

String s1 = "00010000";         println(s1);             // Prints "00010000"

                                println(unbinary(s1));   // Prints "16"

String s2 = "FF";               println(unhex(s2));      // Prints "255"

int i = 65;                     println(i);              // Prints "65"

                                println(str(i));         // Prints "65"

                                println(float(i));       // Prints "65.0"

                                println(binary(i));      // Prints "00000000000000000000000000100001"

                                println(char(i ));       // Prints "A"

String s = String.valueOf(i);   println(s);              // Prints "65"

byte b = 67;                    println(b);              // Prints "67"          

                                println(char(b ));       // Prints "C"

                                println(int(b ));        // Prints "67"  

                                println(hex(b ));        // Prints "43" 

                                println(str(b));         // Prints "67"                          

char c = 'E';                   println(c);              // Prints "E"

                                println(byte(c ));       // Prints "69"

                                println(str(c));         // Prints "E"

float f = 32.6;                 println(f);              // Prints "32.6"

                                println(int(f ));        // Prints "32" 

float a = 90f;                  println(int(a ));        // Prints "90.0" 

                                println(PI);             // Prints "3.1415927"

                                println(TWO_PI);         // Prints "6.2831855"

                                println(nf(TWO_PI,1,3)); // Prints "6.283"

=======================Math==============================

println(abs(-3.33));           // 3.33

println(ceil(8.22));           // 9

println(constrain(100,30,70)); // 70

println(dist(0, 0, 1, 1));     // 1.4142135      dist(x1, y1, x2, y2) vector distance

println(exp(1.0));             // 2.7182817

println(floor(2.88));          // 2

println(lerp(0, 5, .3));       // 1.5            lerp(start, stop, amt)

println(log(2.7182817));       // 0.99999994

println(mag(1,1));             // 1.4142135

println(mag(1,1,1));           // 1.7320508

println(map(20, 0,60, 0, 1));  // 0.33333334     map(value, from_min, from_max, to_min, to_max)

println(max(5, 9));            // 9

println(max(-4, -12));         // -4

println(max(12.3, 230.24));    // 230.24

println(min(5, 9));            // 5

println(min(-4, -12));         // -12

println(min(12.3, 230.24));    // 12.3

println(norm(20,0,60));        // 0.33333334

println(pow(2,3));             // 8.0

println(round(9.2));           // 9

println(round(9.5));           // 10

println(sq(-5));               // 25.0

println(sqrt(625));            // 25.0

println(acos(0.9));            // 0.45102686     

println(asin(.9));             // 1.1197695 

println(atan(.9));             // 0.7328151 

println(atan2(.6,.9));         // 0.5880026

println(cos(0.9));             // 0.62161    

println(sin(.9));              // 0.7833269 

println(tan(.9));              // 1.2601582

println(degrees(.9));          // 51.566196

println(radians(33.9));        // 0.59166664

=======================%(modulo)=======================

println( 5 % 4);               // 1

println( 125 % 60);            // 5

println( 123.4567 % .01);      // 0.0067059454     123.45

//frame                        = (frame+1) % numFrames;    // Use % to cycle through frames

======================(bitwise OR)================================

int a = 205;                   // In binary: 11001101

int b = 45;                    // In binary: 00101101

int c = a | b;                 // In binary: 11101101

println(c);                    // In binary: 11101101  Prints "237"

======================(bitwise AND)=================================

int a1 = 207;                  // In binary: 11001111

int b1 = 61;                   // In binary: 00111101

int c1 = a1 & b1;              // In binary: 00001101

println(c1);                   // In binary: 00001101 Prints "13"

color argb                   = color(204, 204, 51, 255);

int a                        = argb >> 24 & 0xFF;// "0xFF" is 00000000000000000000000011111111 

int r                        = argb >> 16 & 0xFF;

int g                        = argb >> 8  & 0xFF;

int b                        = argb       & 0xFF;        

fill(                          r, g, b, a);

rect(                          30, 20, 55, 55);

======================(right shift)==============================

int m                        = 8   >> 3; println(m); // binary: 1000 to 1        // Prints "1"

int n                        = 256 >> 6; println(n); // binary: 100000000 to 100 // Prints "4"   

int o                        = 16  >> 3; println(o); // binary: 10000 to 10      // Prints "2"   

int p                        = 26  >> 1; println(p); // binary: 11010 to 1101    // Prints "13"

======================(left shift) ============================

int m                        = 1  << 3;  println(m); // binary: 1 to 1000        // Prints "8"

int n                        = 1  << 8;  println(n); // binary: 1 to 100000000   // Prints "256"   

int o                        = 2  << 3;  println(o); // binary: 10 to 10000      // Prints "16"

int p                        = 13 << 1;  println(p); // binary: 1101 to 11010    // Prints "26"

======================bigEndian===============================

int hi                       = b[ix]   & 0xff;       // bytes -128 to 127, converts to unsigned...

int lo                       = b[ix+1] & 0xff;

int el                       = (int)((hi<<8)|lo);      // big endian!

=======================bigEndianHiLo===============================

int hi                        = b[ix]   & 0xff;       // bytes -128 to 127, converts to unsigned...

int lo                        = b[ix+1] & 0xff;

int el                        = (int)((hi<<8)|lo);      // big endian!

======================SAVE_PICTURE_FORMATS==========================================

line(20, 20, 80, 80);

save("diagonal.tif");                 // Saves a TIFF file named "diagonal.tif" 

line(80, 20, 20, 80);

save("cross.tga");                    // Saves a TARGA file named "cross.tga"

                                      //TIFF (.tif), TARGA (.tga), JPEG (.jpg), or PNG (.png).

PImage img;

void setup() 

{ img = loadImage("laDefense.jpg");   // Images must be in the "data" directory to load correctly

}

void draw() 

{ image(img, 0, 0);                  // Loads an image into a variable of type PImage. Four types of images ( .gif, .jpg, .tga, .png)

}

======================Format_Numbers_For_Text_Files=============================

float number                = 123.456789;

float numb2                 = number - number % .01;   println( numb2 );        // 123.45

println(                      100000000*numb2);                                 // 1.23449999E10

System.out.printf(           "%7.2f",number);                                   // 123.46123.45679

String str1                 = str(number);             println( str1 );         // [0] "123.45679"

String[] str2               = split(str1, ' ');        println( str2 );         // [0] "123.45679"

saveStrings(                 "nouns2.txt",  str2);  

String words                = "apple bear cat dog";

String[] list               = split(words, ' ');

saveStrings(                 "nouns.txt", list);                                // Writes strings to file on separate line

String a                    = "384762387642736842734"; println(a);              // 384762387642736842734

float f                     = Float.parseFloat(a);     println("float="+f);     // float=3.847624E20

f                           = float(a);                println("float="+f);     // float=3.847624E20

double d                    = Double.parseDouble(a);   println("double="+d);    // double=3.8476238764273684E20

int ii                      = int(f/10E15);            println("integer="+ii);  // integer=38476

float numb3                 = f/10E15 ; 

float numb4                 = numb3 - numb3 % .01 ;    println( numb4 );        // 38476.23

println(                      100000000*numb4);                                 // 3.84762302E12

=====================keyCode===================================

void                         draw() 

{ if(keyPressed) 

{ if(key     == 'w')         { println("key pressed is w ")    ;} //key pressed is w

  if(key     == 's')         { println("key pressed is " + key);} //key pressed is s

  if(keyCode == UP)          { println("key pressed is up " )  ;} //key pressed is up

}

} 

=====================keyReleased===================================

void                         draw()     {}         // Empty draw() needed to keep the program running

void                         keyPressed() 

{ println(                  "pressed " +key + " " + int(key) + " " + keyCode ); //  pressed a 97 65

}

void                         keyTyped() 

{ println(                  "typed "   +key + " " + int(key) + " " + keyCode);  // typed a 97 0

}

void                          keyReleased() 

{ println(                   "released "+key + " " + int(key) + " " + keyCode);  // released a 97 65

}

=====================keyPress_Case===================================

void                         keyPressed()

{ cnt++;

  if                         (cnt>14)cnt=0;

  switch                     (cnt)

{ case 0  :                  s= new DoubleCone(g,resolution,resolution);         break;

  case 1  :                  s= new EnnepersSurface(g,resolution,resolution);    break;

  case 2  :                  s= new FishSurface(g,resolution,resolution);        break;

  case 3  :                  s= new Horn(g,resolution,resolution);               break;

  case 4  :                  s= new JetSurface(g,resolution,resolution);         break;

  case 5  :                  s= new MoebiusStrip(g,resolution,resolution);       break;

  case 6  :                  s= new Pillow(g,resolution,resolution);             break;

  case 7  :                  s= new Shell(g,resolution,resolution);              break;

  case 8  :                  s= new SnailSurface(g,resolution,resolution);       break;

  case 9  :                  s= new Sphere(g,resolution,resolution);             break;

  case 10 :                  s= new Spring(g,resolution,resolution);             break;

  case 11 :                  // s= new SuperShapes(g,resolution,resolution);     break;

  case 12 :                  s= new TearDrop(g,resolution,resolution);           break;

  case 13 :                  s= new TetrahedralEllipse(g,resolution,resolution); break;

  case 14 :                  s= new WhitneyUmbrella(g,resolution,resolution);    break;

}

}

import java.awt.event.KeyEvent; 

import java.awt.event.KeyEvent;

int[] ALFABET;

ALFABET = new int[27];

ALFABET[0]= KeyEvent.VK_A; // 65

println(ALFABET[0]);

ALFABET[0]= KeyEvent.VK_B; // 66

println(ALFABET[0])

char c = 'E';                   println(c);              // Prints "E"

                                println(byte(c ));       // Prints "69"

                                println(str(c));         // Prints "E"

=====================HASHMAP============================

import                       java.util.Iterator;

import                       java.util.Map;

HashMap hm                  = new HashMap();

hm.put(                      "Ava", 1);

hm.put(                      "Cait", 35);

hm.put(                      "Casey", 36);

Iterator i                  = hm.entrySet().iterator();  // Get an iterator

while                         (i.hasNext()) 

{ Map.Entry me              = (Map.Entry)i.next();

  print(                      me.getKey() + " is ");

  println(                    me.getValue());

}

====================

//Ava is 1

//Cait is 35

//Casey is 36

======================STRING============================

String men                  = "Chernenko,Andropov,Brezhnev";

String[] list               = split(men, ',');             // list[0] is now "Chernenko", list[1] is "Andropov"...

String joinedNames          = join(list, " : "); 

println(                      joinedNames);                // Prints "Chernenko:Andropov:Brezhnev" 

String numbers              = "8     67 5  309";

int[] nums                  = int(split(numbers, ' '));    // nums[0] is now 8, nums[1] is now 67...

String joinedNumbers        = join(nf(nums, 0), ", "); 

println(                      joinedNumbers);             // Prints "8, 0, 0, 0, 0, 67, 5, 0, 309" 

String s1                   = "    Somerville MA ";

String s2                   = trim(s1);

println(                      s1);                        // Prints "    Somerville   MA "

println(                      s2);                        // Prints "Somerville   MA"

String str1                 = "CCCP";

char   data[]               = {'C', 'C', 'C', 'P'};

String str2                 = new String(data);

println(                      str1);                      // Prints "CCCP" to the console

println(                      str2);                      // Prints "CCCP" to the console

String p                    = "potato";

if                            (p == "potato") {println("p == potato, yep.");  }    // This will not print

if                            (p.equals("potato")) {  println("Yes");    }         //Yes

String quoted               = "This one has \"quotes\"";

println(                       quoted);                                            // This one has "quotes"

String t                    = "a b";

String[] q                  = splitTokens(t);

println(                      q[0]);                         // Prints "a"

println(                      q[1]);                         // Prints "b"

String s                    = "a, b c ,,d "; 

String[] q2                 = splitTokens(s, ", ");          // ", " means break whenever comma *or* a space 

println(                      q2.length + " values found");  // Prints "4 values found"

println(                      q2[0]);  // Prints "a"         // multiple adjacent delimiters as a single break.

println(                      q2[1]);  // Prints "b"

println(                      q2[2]);  // Prints "c"

println(                      q2[3]);  // Prints "d"

int a                       = 200, b=40, c=90;

float d                     = 200.94, e = 40.2;

println( nf(a,10)+" "         +nf(b,5)+" "+nf(c,3)+" "+nf(d,10,4)+" "+nf(e, 5, 3)); //"0000000200 00040 090 0000000200.9400 00040.200"

float f                     = 42525.34343; 

println(                      nfc(f, 2) );  // Prints "42,525.34"

int a2                      = 200, b2=-40, c2=90;

float d2                    = 200.94, e2 = -40.2;

println( nfs(a2, 10)+" "      +nfs(b2,5)+" "+nfs(c2,3)+" "+nfs(d2,10,4)+" "+nfs(e2,5,3)); //"0000000200 -00040  090  0000000200.9400 -00040.200"

======================STRING2NUMB============================

float number                = 123.456789;

float numb2                 = number - number % .01;   println( numb2 );        // 123.45

println(                      100000000*numb2);                                 // 1.23449999E10

System.out.printf(           "%7.2f",number);                                   // 123.46123.45679

String str1                 = str(number);             println( str1 );         // [0] "123.45679"

String[] str2               = split(str1, ' ');        println( str2 );         // [0] "123.45679"

saveStrings(                 "nouns2.txt",  str2);  

String words                = "apple bear cat dog";

String[] list               = split(words, ' ');

saveStrings(                 "nouns.txt", list);                                // Writes strings to file on separate line

String a                    = "384762387642736842734"; println(a);              // 384762387642736842734

float f                     = Float.parseFloat(a);     println("float="+f);     // float=3.847624E20

f                           = float(a);                println("float="+f);     // float=3.847624E20

double d                    = Double.parseDouble(a);   println("double="+d);    // double=3.8476238764273684E20

int ii                      = int(f/10E15);            println("integer="+ii);  // integer=38476

                              println(PI);                                      // Prints "3.1415927"

                              println(TWO_PI);                                  // Prints "6.2831855"

                              println(nf(TWO_PI,1,3));                          // Prints "6.283"

=====================CONTROL============================

for                          (int i = 0; i <= 10; i += 2) 

{ if                         (i == 6)                           // If i is 60 skip to the next iteration, ############

{ continue;    

} else

{ print(                     i + " ");                          // 0 2 4 8 10  

}                 

} println();

int i                      = 0;

while                        (i < 8) 

{ print(                     i + " ");                          //0 1 2 3 4 5 6 7 

  i                        = i + 1;

} println(); 

int s                      = (i > 5)  ? 10 : 255;

println(                     "i = " + i + " s = " + s);        // i = 8 s = 10

char letter                = 'B';

if                           (letter != 'A') println("Not_A"); // Not_A

switch(                      letter) 

{ case 'A':                  println("Alpha");   break;        // Does not execute

  case 'B':                  println("Bravo");   break;        // Prints "Bravo"   

  default :                  println("Zulu") ;   break;        // Does not execute

}

=====================TIME===================================

println(                     "month = "       + month());  //month = 5

println(                     "day = "         + day());    //day = 14

println(                     "year = "        + year());   //year = 2013

println(                     "hour = "        + hour());   //hour = 17

println(                     "minute = "      + minute()); //minute = 5

println(                     "second = "      + second()); //second = 50

println(                     "milliseconds = "+ millis()); //milliseconds = 371

float x;

for                          (int i=0; i <10;  i++)

{ x = float(i)/10;

  delay(4250);               // delay 4250msec

  println( x); 

}

=====================PROMPT===================================

int num                    = 0;

void                         setup()

{ size(                      200,200);

  println(                  "Please press a number between 1-9"); //Please press a number between 1-9

}

void                         draw()

{ background(                255);

  if                         (num !=0) 

{ println(                  "This is Number "+ num);              //This is Number 3

  num                      = 0;

}

}

void                         keyPressed()

{ int                        keyNum = Character.getNumericValue(key);

  if                         (keyNum<=9 && keyNum>0)  num = keyNum;

}

=====================User_Input=====================================

PFont f;

String typing           = "";    // Variable to store text currently being typed

String saved            = "";    // Variable to store saved text when return is hit

void                      setup() 

{ size(                   300,200);

  f                     = createFont("Arial",16,true);

}

void                      draw() 

{ background(             255);

  int indent            = 25;

  textFont(               f);           

  fill(0);

  text(                  "ClickHere and type. \nHit return to save what you typed. ", indent, 40); 

  text(                   typing,indent,90);

  text(                   saved,indent,130);

}

void                      keyPressed() 

{ if                      (key == '\n' )            // If the return key is pressed, save the String and clear it

{ saved                 = typing;

  typing                = "";                       // A String can be cleared by setting it equal to ""

} else 

{ typing                = typing + key;             // Otherwise, concatenate typed to end of String variable.

}

}

void                      mousePressed()

{ save(                  "pict.jpg"); 

}

 =====================PLOT_And_Save===========

PrintWriter output;

float x0 = 0, y0=0;

float x1, y1;

void                                 setup() 

{ output                           = createWriter("commaSep.txt");   // Create a new file in the sketch directory

  size                               (200, 300); 

  background                         (255);

  stroke                             (153);    // grey

  smooth                             ();

  strokeWeight(5);  

  for                               (int i=0; i <10;  i++)

{ x1                              = float(i)*10;

  y1                              = x1* x1/100;

  line                              (x0, y0, x1, y1);

  output.println(                   x1 + "     ," + y1);

  x0                              = x1;

  y0                              = y1;

}

  output.flush();                  // Writes the remaining data to the file

  output.close();                  // Finishes the file

  exit();                          // Stops the program

}

==================commaSep.txt========================

0.0      ,0.0

10.0     ,1.0

20.0     ,4.0

30.0     ,9.0

40.0     ,16.0

50.0     ,25.0

60.0     ,36.0

70.0     ,49.0

80.0     ,64.0

90.0     ,81.0

================Comma_Separated_Text===============================

int[] data;

String[] grafpts;

float x0 = 0, y0=0;

float x1, y1;

void setup() 

{ size(200,200);

  String[] stuff = loadStrings("/Users/don_sauer/Downloads/moreProcessing/Processing_REF/sketch_test_202/data/commaSep.txt");

  //print (stuff.length);

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

{ grafpts = split(stuff[i], ',' );

  println(grafpts[0]);

  x1                              = float(grafpts[0]);

  y1                              = float(grafpts[1]);;

  line                              (x0, y0, x1, y1);

  x0                              = x1;

  y0                              = y1;   

}

}

 ===================Equations_Table===========

float x, y;

float focal =.5;

float xlast = 0 ;

float ylast = 0 ;

float len ;

float slope;

float Rcone;

float arc ;

float circm;

for                      (int i=0; i <=10;  i++)

{ x                    = float(i)/10;                                            // radius

  y                    = x*x/(4*focal);                                          // height at radius

  len                  = sqrt( (x- xlast)* (x- xlast) +(y- ylast)* (y- ylast));  // length to previous radius

  slope                = (y- ylast)/(x- xlast);                                  // slope of length                      

  Rcone                = x*sqrt( slope*slope +1 );                               // outer cone radius

  arc                  = 360*x/Rcone;                                            // outer cone arc in degress

  circm                =  TWO_PI*x;                                              // circum at radius

  println(               "x="+x+" y="+nf(y,1,3) +" len="+nf(len,1,3) +" slope="+nf(slope,1,3)

                       + " Rcone="+nf(Rcone,1,3)+" arc="+nf(arc,1,3) +" circm="+nf(circm,1,3)); 

  xlast                = x ;

  ylast                = y ;

}

  println(               PI);

  println(               TWO_PI);

==========================Result==========================================================

x=0.0 y=0.000 len=0.000 slope=?     Rcone=?     arc=?       circm=0.000

x=0.1 y=0.005 len=0.100 slope=0.050 Rcone=0.100 arc=359.551 circm=0.628

x=0.2 y=0.020 len=0.101 slope=0.150 Rcone=0.202 arc=356.017 circm=1.257

x=0.3 y=0.045 len=0.103 slope=0.250 Rcone=0.309 arc=349.251 circm=1.885

x=0.4 y=0.080 len=0.106 slope=0.350 Rcone=0.424 arc=339.789 circm=2.513

x=0.5 y=0.125 len=0.110 slope=0.450 Rcone=0.548 arc=328.292 circm=3.142

x=0.6 y=0.180 len=0.114 slope=0.550 Rcone=0.685 arc=315.438 circm=3.770

x=0.7 y=0.245 len=0.119 slope=0.650 Rcone=0.835 arc=301.840 circm=4.398

x=0.8 y=0.320 len=0.125 slope=0.750 Rcone=1.000 arc=288.000 circm=5.027

x=0.9 y=0.405 len=0.131 slope=0.850 Rcone=1.181 arc=274.298 circm=5.655

x=1.0 y=0.500 len=0.138 slope=0.950 Rcone=1.379 arc=261.000 circm=6.283

3.1415927

6.2831855

====================Parabola_Equations_Plot=========================================

float x0=0, y0=0;

float x1, y1;

float xoff = 10;

float yoff = 100;

size(300, 300); 

 background(255);

 stroke(15);                              // grey

 smooth();

 strokeWeight(1); 

yoff = height-10 ;

x0 =  xoff;

y0 =  yoff;

line( xoff, 10,  xoff, height-10);

line( xoff,  height-10,  width-10, height-10);

for                                  (int i=0; i <10;  i++)

{ x1 = float(i)*30 + xoff ;

  y1 = -x1* x1/300 + yoff;

  line(x0, y0, x1, y1);

  x0=x1;

  y0=y1;

}

=======================Draw_2D_segments==============================

  float r               = 50; 

  size(                   600, 600); 

  background(             255);

  stroke(                 15);                              // grey

  smooth(                 );

  strokeWeight(           1); 

  float cx              = width/2;

  float cy              = height/2;

  ellipse(                cx, cy , r*2, r*2);

  noFill(                 );                                 // NO FILL

  for                     (int j = 0; j < 3; j ++ )  

{ ellipse(                cx, cy , r*2*(j+1), r*2*(j+1));

  for                     (int i = 0; i < 12; i ++ )  

{ line(                   cx+r*j*cos(PI*i/6),cy+r*j*sin(PI*i/6),cx+r*(j+1)*cos(PI*i/6),cy+r*(j+1)*sin(PI*i/6) );

  println( PI*i/6);

}

}

=======================Create_3D_Parabola==============================

  PVector                 v1, v2 ,v3 , va,vb ,vc,vd;

  float                   x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;

  float r               = 30;

  float focal           = 300;

  void                    setup()

{ size(                   600, 600, P3D);

  vd                    = FindNormal( 50.0, 50.0, 40.0 , 0.0,  50.0, 100.0,  0.0,  0.0,  80.0);

  println(                vd);            // [ 3000.0, -1000.0, 2500.0 ]

}

  void                    draw() 

{ background(             100);

  pushMatrix(             );                       // save orginal set up           

  translate(              300, 300, 0);            // translate origin to center

  rotateX(                PI-mouseY/150.0);        

  rotateZ(                PI/2-mouseX/150.0);

  for                     (int j = 0; j < 6; j ++ )  

{ for                     (int i = 0; i < 12; i ++ )  

{ x1                    = r*j*cos(PI*i/6);

  y1                    = r*j*sin(PI*i/6);

  z1                    = sq((r*j))/focal;

  x2                    = r*j*cos(PI*(i+1)/6);

  y2                    = r*j*sin(PI*(i+1)/6) ;

  z2                    = sq((r*j))/focal;

  x3                    = r*(j+1)*cos(PI*(i+1)/6);

  y3                    = r*(j+1)*sin(PI*(i+1)/6);

  z3                    = sq((r*(j+1)))/focal;

  x4                    = r*(j+1)*cos(PI*i/6);

  y4                    = r*(j+1)*sin(PI*i/6) ;

  z4                    = sq((r*(j+1)))/focal;

  drawPlate(           x1,y1,z1,   x2,y2,z2,   x3,y3,z3,   x4,y4,z4);

}  

} popMatrix();                                      // restore orginal set up 

}

 void drawPlate(       float x1,float y1,float z1,float x2,float y2,float z2,float x3,float y3,float z3,float x4,float y4,float z4)

{ stroke(                 0);

  strokeWeight(           1);

  beginShape(             QUADS);

  vertex(                 x1, y1, z1);

  vertex(                 x2, y2, z2);

  vertex(                 x3, y3, z3);

  vertex(                 x4, y4, z4);

  endShape();

}

 PVector                  FindNormal(float x1,float y1,float z1,float x2,float y2,float z2,float x3,float y3,float z3)

{ v1                    = new PVector(x1, y1, z1);// println(v1); // [ 50.0, 50.0, 40.0 ]

  v2                    = new PVector(x2, y2, z2);// println(v2); // [ 0.0,  50.0, 100.0 ]

  v3                    = new PVector(x3 ,y3, z3);// println(v3); // [ 0.0,  0.0,  80.0 ]

  va                    = v1;

  va.sub(                 v2);                    // println(va); // [ 50.0, 0.0, -60.0 ]

  vb                    = v2;

  vb.sub(                 v3);                    // println(vb); // [ 0.0,  50.0, 20.0 ]

  vc                    = va.cross(vb);           // println(vc); // [ 3000.0, -1000.0, 2500.0 ]

  return                  vc;

}

=======================Create3DParabolaSTL==============================

  PVector                 v1, v2 ,v3 , va,vb ,vc,vd;

  float                   x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;

  float r               = 30;

  float focal           = 300;

  void                    setup()

{ size(                   600, 600, P3D);

  println (               "solid"); 

  for                     (int j = 0; j < 6; j ++ )  

{ for                     (int i = 0; i < 12; i ++ )  

{ x1                    = r*j*cos(PI*i/6);

  y1                    = r*j*sin(PI*i/6);

  z1                    = sq((r*j))/focal;

  x2                    = r*j*cos(PI*(i+1)/6);

  y2                    = r*j*sin(PI*(i+1)/6) ;

  z2                    = sq((r*j))/focal;

  x3                    = r*(j+1)*cos(PI*(i+1)/6);

  y3                    = r*(j+1)*sin(PI*(i+1)/6);

  z3                    = sq((r*(j+1)))/focal;

  x4                    = r*(j+1)*cos(PI*i/6);

  y4                    = r*(j+1)*sin(PI*i/6) ;

  z4                    = sq((r*(j+1)))/focal;

  drawPlate(           x1,y1,z1,   x2,y2,z2,   x3,y3,z3,   x4,y4,z4);

  PrintSTL(            x1,y1,z1,   x2,y2,z2,   x3,y3,z3   );

  PrintSTL(            x3,y3,z3,   x4,y4,z4,   x1,y1,z1   );

}  

}    

  println (               "endsolid"); 

}

  void                    draw() 

{ background(             100);

  pushMatrix(             );                       // save orginal set up           

  translate(              300, 300, 0);            // translate origin to center

  rotateX(                PI-mouseY/150.0);        

  rotateZ(                PI/2-mouseX/150.0);

  for                     (int j = 0; j < 6; j ++ )  

{ for                     (int i = 0; i < 12; i ++ )  

{ x1                    = r*j*cos(PI*i/6);

  y1                    = r*j*sin(PI*i/6);

  z1                    = sq((r*j))/focal;

  x2                    = r*j*cos(PI*(i+1)/6);

  y2                    = r*j*sin(PI*(i+1)/6) ;

  z2                    = sq((r*j))/focal;

  x3                    = r*(j+1)*cos(PI*(i+1)/6);

  y3                    = r*(j+1)*sin(PI*(i+1)/6);

  z3                    = sq((r*(j+1)))/focal;

  x4                    = r*(j+1)*cos(PI*i/6);

  y4                    = r*(j+1)*sin(PI*i/6) ;

  z4                    = sq((r*(j+1)))/focal;

  drawPlate(           x1,y1,z1,   x2,y2,z2,   x3,y3,z3,   x4,y4,z4);

}  

} popMatrix();                                      // restore orginal set up 

}

 void drawPlate(       float x1,float y1,float z1,float x2,float y2,float z2,float x3,float y3,float z3,float x4,float y4,float z4)

{ stroke(                 0);

  strokeWeight(           1);

  beginShape(             QUADS);

  vertex(                 x1, y1, z1);

  vertex(                 x2, y2, z2);

  vertex(                 x3, y3, z3);

  vertex(                 x4, y4, z4);

  endShape(               );

}

 PVector                  FindNormal(float x1,float y1,float z1,float x2,float y2,float z2,float x3,float y3,float z3)

{ v1                    = new PVector(x1, y1, z1);// println(v1); // [ 50.0, 50.0, 40.0 ]

  v2                    = new PVector(x2, y2, z2);// println(v2); // [ 0.0,  50.0, 100.0 ]

  v3                    = new PVector(x3 ,y3, z3);// println(v3); // [ 0.0,  0.0,  80.0 ]

  va                    = v1;

  va.sub(                 v2);                    // println(va); // [ 50.0, 0.0, -60.0 ]

  vb                    = v2;

  vb.sub(                 v3);                    // println(vb); // [ 0.0,  50.0, 20.0 ]

  vc                    = va.cross(vb);           // println(vc); // [ 3000.0, -1000.0, 2500.0 ]

  return                  vc;

}

 void                     PrintSTL(float x1,float y1,float z1,float x2,float y2,float z2,float x3,float y3,float z3)

{ vd                   =  FindNormal( x1,y1,z1,x2,y2,z2,x3,y3,z3 );

  if                      ( vd.x != 0 && vd.y != 0 && vd.z != 0 ) 

{ println(                "facet normal " + vd.x + " " + vd.y + " " + vd.z );

  println (               "outer loop ");

  println(                "vertex " + x1 + " " + y1 + " " + z1 );

  println(                "vertex " + x2 + " " + y2 + " " + z2 );

  println(                "vertex " + x3 + " " + y3 + " " + z3 );

  println (               "endloop");

  println (               "endfacet");

}

}

===================Copy_Output_To_A_File=========

===================Import_Mesh=========

===================Convert_to_3DS=========

===================Can_Built_3ds_files=========

=======================ConvertSTL2SACSII=========================================

ruby /Users/don_sauer/Downloads/2DO/sketch_130802a/convertSTL.rb /Users/don_sauer/Downloads/sketch_130815a/ribbon.stl 

/Users/don_sauer/Downloads/sketch_130815a/ribbon.stl is in BINARY format, 

converting to ASCII: /Users/don_sauer/Downloads/sketch_130815a/ribbon-ascii.stl

======================ARRAY=================================

int[] numbers                = new int[2];

numbers[0]                   = 90;  

numbers[1]                   = 150; 

int[] numbers2               = { 90, 150, 30 }; 

numbers2                     = sort( numbers2 ) ;       println(numbers2);     // { 30, 90,150 } 

String[] north               = { "OH", "IN", "MI"};     println(north);        // north[0] = "OH" 

String[] sa1                 = append(north , "MA");    println(sa1);          //{"OH", "IN", "MI" , “MA”} 

String[] sa2                 = shorten(sa1);            println(sa2);          //{"OH", "IN", "MI"}

String[] a                   = splice(sa2, "KY", 1);    println(a);            //{"OH", “KY”, "IN", "MI"} Splice one value into

String[] south               = { "GA", "FL", "NC"};     println(south);        //{ "GA", "FL", "NC"}

String[] sa3                 = concat(north, south);    println(sa3);          //{"OH", "IN", "MI","GA", "FL", "NC" }

String[] sa4                 = subset(sa3, 1 , 2);      println(sa4);          //{ "IN", "MI" }

//String[] sa5               = arrayCopy(north, south); println(sa5);          //{ "OH", "IN", "MI"}

int[] data                   = {0, 1, 3, 4};            println(data.length);  // Prints "4"

data                         = expand(data);            println(data.length);  // Prints "8"

data                         = expand(data, 512);       println(data.length);  // Prints "512"

String sa[]                  = { "OH", "NY", "MA", "CA"};

sa                           = reverse(sa);             println(sa); //{ "CA", "MA", "NY", "OH"}

====================Print-1D-Array======================

int[] myArray            = {0,1,2,3};

println(myArray);

String[] images          = { "jewels.jpg", "bark.jpg", "dp.jpg", "jeff.jpg"}; 

for                        (int i=0;i<images.length;i++) println("images " +i+"  " +images[i]);

===========================================

[0] 0

[1] 1

[2] 2

[3] 3

images 0  jewels.jpg

images 1  bark.jpg

images 2  dp.jpg

images 3  jeff.jpg

====================Print-2D-Array======================

int[][] myArray2 = { {0,1,2,3}, {3,2,1,0}, {3,5,6,1} }; 

int[][] myArray = {  {0, 1, 2, 3},

                     {3, 2, 1, 0},

                     {3, 8, 3, 4}  };

int     cols = myArray.length;

int     rows = myArray[0].length;

  for (int i = 0; i < cols; i++)

{ for (int j = 0; j < rows; j++) 

{ print( myArray[i][j] + " ");

}

  println(" "); 

}

=======================================

0 1 2 3  

3 2 1 0  

3 8 3 4  

======================PRINT-3D_ARRAYS=========================================

  int   n                    = 3;

  double[][][]                 Array3D = new double[n][n][n];

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

{ for                         (int j=0; j < Array3D[i].length;      j++)

{ for                         (int k=0; k < Array3D[i][j].length;   k++)

{ Array3D[i][j][k]          = i*n*n + j *n  + k;    // initialize contents with double

}                                                   // for(int k=0; k < Array3D[i][j].length;   k++)

}                                                   // for(int j=0; j < Array3D[i].length;      j++)

}                                                   // for(int i=0; i < Array3D.length;         i++)

  println(                    "// Array3D[i][j][k]");

  print(                      "// \n");

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

{ print(                      "// i=" + i );

  for                         (int k=0; k < Array3D[i][0].length;   k++) { print( "   k=" + k ); }

  print(                      "\n");

  for                         (int j=0; j < Array3D[i].length;      j++)

{ print(                      "// j=" + j );

  for                         (int k=0; k < Array3D[i][j].length;   k++)

{ print(                      "   " + Array3D[i][j][k] );

} print(                      "\n");                              // for(int k=0; k < Array3D[i][j].length;   k++)

} print(                      "// \n");                           // for(int j=0; j < Array3D[i].length;      j++)

}                                                                // for(int i=0; i < Array3D.length;         i++)

=======================================

// Array3D[i][j][k]

// 

// i=0   k=0   k=1   k=2

// j=0   0.0   1.0   2.0

// j=1   3.0   4.0   5.0

// j=2   6.0   7.0   8.0

// 

// i=1   k=0    k=1    k=2

// j=0   9.0    10.0   11.0

// j=1   12.0   13.0   14.0

// j=2   15.0   16.0   17.0

// 

// i=2   k=0    k=1    k=2

// j=0   18.0   19.0   20.0

// j=1   21.0   22.0   23.0

// j=2   24.0   25.0   26.0

// 

=====================PRINTARRAYS======================================

void                         Print1DI( int[] array )            //################################

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

  println                    ("i="+i+" val= "+ array[i]);

}

void                         Print1DS( String[]  array )       //################################

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

  println                   ("i="+i+" val= "+ array[i]);

}

void                        Print2DF( float[][] array )         //################################

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

{ for                       (int j = 0; j < array[0].length; j++)  

{ print                     (array[i][j]+" ");

}

  println();

}

} 

=====================ArrayListFunctions==========================

ArrayList words             = new ArrayList<String>(50);

words.add(                 "Java"); 

words.add(                 "is"); 

println(                    "Current size: " + words.size( ));                    //Current size: 2

words.add(                 "a"); 

words.add(                 "powerful"); 

words.add(                 "Last word? ");                                         //Java is a powerful Last word?

println(                    "\nTraverse by index");                                 //Traverse by index

for                         (int i=0; i<5; i++) 

{ print(                    words.get(i) + " ");                                  //Java is a powerful Last word? 

}          

print(                      "\n\n"); 

println(                    "Reverse traverse by index");                           //Reverse traverse by index

for                         (int i=words.size( )-1; i>=0; i--) 

{ print(                    words.get(i) + " ");                                 //Last word?  powerful a is Java

} 

print(                      "\n\n"); 

println(                    "Add values");                                         //Add values

words.add(0,               "Sun's"); 

words.add(4,               "very"); 

words.add(6,               "programming"); 

for                         (int i=0; i<=words.size( )-1; i++) 

{ print(                    words.get(i) + " ");                                 //Sun's Java is a very powerful programming Last word? 

}   

print(                      "\n\n"); 

println(                    "Remove and size 1");                                         //Remove and size 1

println(                    "Size: " + words.size( ));                           // Size: 8

words.remove(             0); 

for                         (int i=0; i<=words.size( )-1; i++) 

{ print(                     words.get(i) + " ");                               //Java is a very powerful programming Last word?  

} 

print(                      "\n\n"); 

println(                    "Remove and size 2");                                //Remove and size 2

println(                     "Size: " + words.size( ));                           //Size: 7 

words.remove(               3);

words.remove(               4); 

for                          (int i=0; i<=words.size( )-1; i++) 

{ print(                      words.get(i) + " ");                               //Java is a powerful Last word? 

}

print(                       "\n\n"); 

println(                     "Set");                                              // Set

words.set(                  0, "Suns's Java"); 

words.set(                  4, "programming language"); 

words.add(                  5, "but I prefer Captain Crunch"); 

for                          (int i=0; i<=words.size( )-1; i++) 

{ print(                     words.get(i) + " ");                               // Suns's Java is a powerful programming language but I prefer Captain Crunch

} 

=====================PARTICLE_ARRAYLIST===========================

ArrayList                      particles;

void                           setup() 

{ size(                        200,200);

  particles                  = new ArrayList();

  smooth(                      );

}

void                           draw() 

{ particles.add(               new Particle());                             // Particle object added to ArrayList every cycle draw().

  background(                  255);

  for                          (int i = 0; i < particles.size(); i++ ) 

{ Particle p                 = (Particle) particles.get(i);                 // Iterate ArrayList and get each Particle

  p.run(                       );

  p.gravity(                   );

  p.display(                   );

}

  if                           (particles.size()>100){particles.remove(0);} // If ArrayList more than 100 delete first element

}

class                          Particle                                  // A simple Particle class

{ float                        x, y,xspeed,yspeed; 

Particle(                   ) 

{ x                          = mouseX;

  y                          = mouseY;

  xspeed                     = random(-1,1);

  yspeed                     = random(-2,0);

}

void                           run() 

{ x                          = x + xspeed;

  y                          = y + yspeed;

}

void                           gravity() 

{ yspeed                    += 0.1;

}

void                           display() 

{ stroke(                      0);

  fill(                        0,75);

  ellipse(                     x,y,10,10);

}

}

void                           mousePressed()

{ save(                       "pict.jpg"); 

}

===================AppendArray=================================

Ball[] balls             = new Ball[1];               // We start with an array with just one element.

float gravity            = 0.1;

void                       setup() 

{ size(                    200,200);

  smooth(                  );

  balls[0]               = new Ball(50,0,16);         // Initialize ball index 0

}

void                       draw()                   // Update and display all balls

{ background(              255);

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

{ balls[i].gravity(        );                     

  balls[i].move(           );

  balls[i].display(        );

}}

void                       mousePressed()                  // A new ball object

{ Ball b                 = new Ball(mouseX,mouseY,16);         // Make a new object at the mouse location.

  balls                  = (Ball[]) append(balls,b);           // append() element to the end of the array. 

}

class                      Ball 

{ float                    x,y,speed, w;

Ball(                    float tempX, float tempY, float tempW) 

{ x                      = tempX;

  y                      = tempY;

  w                      = tempW;

  speed                  = 0;

}

void                       gravity() 

{ speed                  = speed + gravity;                // Add gravity to speed

} 

void                       move() 

{ y                      = y + speed;                        // Add speed to y location

  if                       (y > height)                      // If square reaches the bottom// Reverse speed

{ speed                  = speed * -0.95;

  y                      = height;

}}

void                       display() 

{ fill(                    175);                           // Display the circle

  stroke(                  0);

  ellipse(                 x,y,w,w);

}}  

void                       keyPressed()

{ save(                    "pict.jpg"); 

}

=====================SAVEJPG===================================

void                         keyPressed()

{ save(                     "pict.jpg"); 

  if                         (key=='s') {save( "pict.jpg");}

}

void                         mousePressed()

{ save(                     "pict.jpg"); 

}

if                          (mousePressed) { ca.drawBoxAt(mouseX,mouseY,5,1); }

====================CLICK_VIEW==============================

PFont                   font;

String                  str1,str2;

ArrayList pt          = new ArrayList();

void                    setup() 

{ size(                 200, 200);

  font                =  createFont("Arial",9,true);

  //font              = loadFont("/Users/don_sauer/Downloads/more/sketch_131105a/data/Serif-12.vlw");

  textFont(             font,12);

  fill(                 255, 0, 0);

}

void                    draw() 

{ strokeWeight(         5);

  background(           255);

  str1                = String.valueOf(mouseX) +","+String.valueOf(mouseY);

  text(                 str1, mouseX,  mouseY); 

  if                    (pt != null)

{ for                   (int i = 0; i < pt.size(); i++ ) 

{ XYpt p              = (XYpt) pt.get(i);

  point(                p.x, p.y );

  str2                = String.valueOf(int(p.x)) +","+String.valueOf(int(p.y));

  text(                 str2, p.x,  p.y);

} strokeWeight(         1);

  for                   (int i = 1; i < pt.size(); i++ ) 

{ XYpt p1             = (XYpt) pt.get(i-1);

  XYpt p2             = (XYpt) pt.get(i);

  line(                 p1.x, p1.y , p2.x, p2.y);

} if                    (pt.size()>0)

{ XYpt p3             = (XYpt) pt.get(pt.size()-1);

  line(                 p3.x, p3.y , mouseX, mouseY);

}}

  if                    (mousePressed ) 

{ pt.add(               new XYpt(mouseX, mouseY));

  println(              pt.size()+" "+ mouseX+" "+mouseY);

  delay(                550);

}}

void                    keyPressed()

{ //int                 keyNum = Character.getNumericValue(key);

  //if                  (keyNum<=9 && keyNum>0)  num = keyNum;

  save(                 "pict.jpg");               

}

class                   XYpt 

{ float                 x;

  float                 y; 

XYpt(                 float xin, float yin) 

{ x                   = xin;

  y                   = yin;

}}

==================

1 39  79

2 69  127

3 141 121

4 135 70

5 83  57

6 86  94

===================Display-Mouse=================================

PFont metaBold;

String str1;

void setup() 

{ size(200, 200);

  //metaBold = loadFont("CourierNew36.vlw");

  metaBold =  createFont("Arial",9,true);

  textFont(metaBold);

  stroke(0);

  fill(255, 0, 0);

  textSize(12);

}

void draw() 

{ background(204); 

  if (mousePressed ) 

{ str1 =str(mouseX)+ ", "+ str(mouseY) ;

  text(str1, 3, 15);  

}

}

void keyPressed() { save("pict.jpg"); }

========================MOUSE_OVER===========================================

int     rectX, rectY;                    // Position of square button

int     circleX, circleY;                // Position of circle button

int     rectSize               = 90;     // Diameter of rect

int     circleSize             = 93;     // Diameter of circle

boolean rectOver               = false;

boolean circleOver             = false;

color   rectColor, circleColor, baseColor;

color   rectHighlight, circleHighlight;

color   currentColor;

void                             setup() 

{ size(                          640, 360);

  rectColor                    = color(0);

  rectHighlight                = color(51);

  circleColor                  = color(255);

  circleHighlight              = color(204);

  baseColor                    = color(102);

  currentColor                 = baseColor;

  circleX                      = width/2+circleSize/2+10;

  circleY                      = height/2;

  rectX                        = width/2-rectSize-10;

  rectY                        = height/2-rectSize/2;

  ellipseMode(                   CENTER);

}

void                             draw() 

{ update(                      mouseX, mouseY);

  background(                    currentColor);

  if                             (rectOver)   { fill(rectHighlight);} 

  else                           { fill(rectColor); }

  stroke(                        255);

  rect(                          rectX, rectY, rectSize, rectSize);

  if                             (circleOver) { fill(circleHighlight) ; } 

  else                           { fill(circleColor);  }

  stroke(                        0);

  ellipse(                       circleX, circleY, circleSize, circleSize);

}

void                             update(int x, int y) 

{ if                             ( overCircle(circleX, circleY, circleSize) ) 

{ circleOver                   = true;

  rectOver                     = false;

} else if                        ( overRect(rectX, rectY, rectSize, rectSize) ) 

{ rectOver                     = true;

  circleOver                   = false;

} else                           {   circleOver = rectOver = false; }

}

void                             mousePressed() 

{ if                            (circleOver) {   currentColor = circleColor;  }

  if                            (rectOver)   {   currentColor = rectColor;    }

}

boolean                         overRect(int x, int y, int width, int height)  

{ if                            (mouseX >= x && mouseX <= x+width &&   mouseY >= y && mouseY <= y+height)  

{ return                        true; } 

  else                          { return false; }

}

boolean                          overCircle(int x, int y, int diameter) 

{ float disX                   = x - mouseX;

  float disY                   = y - mouseY;

  if                             (sqrt(sq(disX) + sq(disY)) < diameter/2 ) {  return true; } 

  else                           { return false; }

}

==================pushed-pulled-by-cursor==============================

Follow 1. Based on code from Keith Peters (www.bit-101.com).

A line segment is pushed-pulled-by-cursor.

float x = 100;

float y = 100;

float angle1 = 0.0;

float segLength = 50;

void setup() 

{ size(200, 200);

  smooth(); 

  strokeWeight(20.0);

  stroke(0, 100);

}

void draw() 

{ background(226);

  float dx = mouseX - x;

  float dy = mouseY - y;

  angle1 = atan2(dy, dx);  

  x = mouseX - (cos(angle1) * segLength);

  y = mouseY - (sin(angle1) * segLength);

  segment(x, y, angle1); 

  ellipse(x, y, 20, 20);

}

void segment(float x, float y, float a) 

{ pushMatrix();

  translate(x, y);

  rotate(a);

  line(0, 0, segLength, 0);

  popMatrix();

}

===================Rollover-button=============================

Roll over the colored squares in the center of the image to change the color of the outside rectangle.

int rectX, rectY;      // Position of square button

int circleX, circleY;  // Position of circle button

int rectSize = 50;     // Diameter of rect

int circleSize = 53;   // Diameter of circle

color rectColor;

color circleColor;

color baseColor;

boolean rectOver = false;

boolean circleOver = false;

void setup()

{ size(200, 200);

  smooth();

  rectColor  = color(0);

  circleColor = color(255);

  baseColor   = color(102);

  circleX     = width/2+circleSize/2+10;

  circleY     = height/2;

  rectX       = width/2-rectSize-10;

  rectY       = height/2-rectSize/2;

  ellipseMode(CENTER);

}