PShape s;

void setup() {
s = loadShape("shape.svg");
size(500, 500); //set the size of the window (& the pdf document)
smooth();
noLoop();
}

void draw() {
//set the background color to be white
background(255);

//this code randomly scales, rotates, and translates the shape
for (int i=0; i<10;i++)
{
pushMatrix(); //remember the current position and rotation
int randomSize=(int)random(100);
translate(random(width), random(height)); //move to a random position
rotate(random(radians(360))); //rotate a random angle
shape(s, 0, 0, randomSize, randomSize); //draw the shape at a random size
popMatrix(); //return to the original position and rotation
}

//this code creates a five pointed circular pattern from the shape
translate(width/2, height/2);
for (int i=0;i<5;i++)
{
pushMatrix(); //remember the current position and rotation
translate (10,10); //move 10 pixels away from the current position in the x and y directions
shape(s, 0, 0, 20,20); //draw the shape, size = 20 pixels
popMatrix(); //return to the original position and rotation

pushMatrix(); //remember the current position and rotation
translate (20,50); //move 20 pixels in x and 50 pixels in y
shape(s, 0, 0, 20,20); //draw the shape, size = 20 pixels
popMatrix(); //return to the original position and rotation

rotate(radians(72));
}
}

void setup() {
//set the size of the window (& the pdf document)
size(640, 500);
smooth();
noLoop();
stroke(100,100,50); //use a yellow-green color
}

void draw() {
float Y, previousY;
int x;
Y=0;
previousY=Y;
background(255);
for (x=0;x<width;x++)
{
previousY=Y;
//play with this equation
Y=(sin(radians(x))*x/5)+200;
line(x-1, height-previousY, x, height - Y);
}
//close the box
line(x, height-previousY, x, height);
line(x, height, 0, height);
}

/*
F = forward
+ = left turn by angle
- = right turn by angle
[ = remember current state
] = return to last remembered state

generate a pattern using LSystem, which takes 3 parameters
a STARTING STRING, a RULE, and an ANLGE:
myLSystem = new LSystem(STARTING STRING, RULE, ANLGE);

here's an example, starting with starting string = F, rule= F+F--F+F, angle=60:
myLSystem = new LSystem("F", "F+F--F+F", 60);
*/

import processing.pdf.*;

LSystem myLSystem;
float scaleFactor=.5;
int iterations =3;
int startingSize=200;
int i;

void setup() {
size(500, 500); //set the size of the window (& the pdf document)
smooth();
noLoop(); //only draw the design once
stroke(100,100,50); //use a yellow-green color

//scales the pattern down as iterations increase
scaleFactor = 1/pow(3,iterations);
}

void draw() {
//define the design
//myLSystem = new LSystem(STARTING STRING, RULE, ANLGE);
myLSystem = new LSystem("F", "F+F--F+F", 60); //Koch curve
//myLSystem = new LSystem("F-F-F-F-F-F", "F+F--F+F", 60); //Koch snowflake
//myLSystem = new LSystem("F+F+F+F", "F+F-F-F+F", 90); //square variation on Koch
//myLSystem = new LSystem("F", "F+[F]--[F]+", 30); //tree
//myLSystem = new LSystem("F-F-F-F-F", "FF+F+F+F+F+F", 72); //pentagonal pattern
//myLSystem = new LSystem("F", "F+[F]--[F]+", 30); //tree
//generate the design
myLSystem.applyRuleToAxiom(iterations,startingSize,scaleFactor);
//set a white background
background(255);
//move to an appropriate location on the page
translate(width/2, height/2);
//draw the design to the screen
myLSystem.render();
}

void keyPressed() {
//if the 'q' key is pressed, generate a PDF & quit
if (key == 'q') {
String fileName= "LSystem"+millis()+".pdf"; //create a unique name for your file
beginRecord(PDF, fileName);
draw();
endRecord();
exit();
}
else
{
redraw();
}
}

class LSystem
{
int steps = 0;
int randomness;

String axiom;
String rule;
String production;
float drawLength;
float theta;
float scaleFactor;
int x=0;

int generations;

//default system is a koch curve
LSystem() {
axiom = "F";
rule = "F+F--F+F";
theta = radians(60.0);
reset();
}

LSystem (String axiomIn, String ruleIn, float thetaIn) {
axiom = axiomIn;
rule = ruleIn;
theta = radians(thetaIn);
reset();
}

void reset() {
production = axiom;
generations = 0;
}

int getAge() {
return generations;
}

//turns the final rule into a drawing on the screen
void render() {

steps = production.length();

for (int i = 0; i < steps; i++) {
char step = production.charAt(i);
if (step == 'F') {
line(0, 0, 0, -drawLength);
translate(0, -drawLength);
}
else if (step == 'L') {
line(0, 0, 0, -(drawLength*2));
translate(0, -(drawLength*2));
}
else if (step == '+') {
rotate(theta);
}
else if (step == '-') {
rotate(-theta);
}
else if (step == '[') {
pushMatrix();
}
else if (step == ']') {
popMatrix();
}
}
}

void applyRuleToAxiom(int gen, int startLength, float scaleFactor) {
drawLength=startLength*scaleFactor;
while (getAge() < gen) {
production = iterate(production, rule);
}
print (axiom);
print (" --> ");
println(production);
}

float theta;
int trunkWidth,trunkHeight;

//variables to play with
int initialTrunkWidth =50;
int initialTrunkHeight=100;
int minBranchLength=18;
int minBranchWidth=3;
int branchAngle = 30;
int randomNessAngle=15;

void setup() {
size(640, 500); //set the size of the window (& the pdf document)
smooth();
noLoop();
//set the name of the pdf document
trunkWidth=initialTrunkWidth;
trunkHeight=initialTrunkHeight;
keyPressed();
}

void draw() {
//set the background color to be white
background(255);
//set the foreground color to be deep blue
stroke(50,50,100);
//start the tree from the bottom of the screen
translate(width/2,height);
// Draw the trunk
strokeWeight(trunkWidth);
line(0,0,0,-90);
// Move to the end of that line
translate(0,-90);
// Start the recursive branching!
branch(trunkHeight,trunkWidth);
}

void keyPressed() {
//if the 'q' key is pressed, finish drawing the PDF & quit
if (key == 'q') {
String fileName= "tree"+millis()+".pdf"; //create a unique name for your file
beginRecord(PDF, fileName);
draw();
endRecord();
exit();
}
//if any other key is pressed, draw a new tree
else {
redraw();
}
}

void branch(float h, int w) {
//each branch will be between .7 & .9 * the size of the previous one
h = h*random(.7,.9);
//the width of each branch decreases at each iteration
w=int(w/1.4);

float a = random (branchAngle-randomNessAngle, branchAngle+randomNessAngle);
theta = radians(a);
// All recursive functions must have an exit condition!!!!
// Here, ours is defined by the max branch lengths & widths
if (h > minBranchLength & w > minBranchWidth) {

//right branch
pushMatrix(); // Save the current state of transformation (i.e. where are we now)
rotate(theta); // Rotate by theta
strokeWeight(w); //set the width of the branch
line(0, 0, 0, -h); // draw the branch
translate(0, -h); // move to the end of the branch
branch(h,w); // Ok, now call myself to draw two new branches!!
popMatrix(); // Whenever we get back here, we "pop" in order to restore the previous matrix state

void setup() {
pinMode(sensorPin, INPUT);
digitalWrite(sensorPin, HIGH); //turns on the internal pull-up resistor

pinMode(internalLED, OUTPUT);
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
pinMode(LED3, OUTPUT);
pinMode(LED4, OUTPUT);

digitalWrite(internalLED, HIGH);
Serial.begin(9600);
}

void loop() {
sensorValue=analogRead(sensorPin);
Serial.println(sensorValue);
delay(100);