//import processing.opengl.*;
//import java.util.*;


// test library for simple geometric objects and methods
// recursion
// sierpinski carpet grows in time
// exploring self similarity
// by luisBlackaller.com

//click if it stops

Point2D A;
Point2D B;

float depth = 1, x0,y0;



void setup() {
  framerate(24);
 
  size(400, 400/*, OPENGL*/);
  background(210,20,30);
  noStroke();
  A = new Point2D(0,0);
  B = new Point2D(width,0);
  

  
 
  
   
}

void draw() {
  
  //background(210,20,30);
  //fill(210,20,30,50);
  //rect(-1,-1,800,800);
  
  carpet(A,B,depth);
  
  
  if (depth<6){
  A.x=A.x-1f;
  B.x=B.x+1f;
  A.y=A.y-1f;
  B.y=B.y-1f;
  depth = depth+0.02f;
  }
 	  
}


void mousePressed() 
{ A = new Point2D(0,0);
  B = new Point2D(width,0);
  depth = 1;
  fill(210,20,30,100);
  rect(-1,-1,800,800);
}










/*************** specific methods for this project ***************/

/*Triangle2D rectTriangleCW (Point2D C, Point2D D, float angle){ // clockwise recangle triangle with A, B in it. angle is the angle EDC in (0,PI)
  Point2D E;
  E = new Point2D(  D.x + ( cos(angle) * C.x ), D.y + ( cos(angle) * C.y ) );
  return(new Triangle2D(C,D,E));
}

Polygon2D squareCW (Point2D A, Point2D B){ // clockwise square with A, B in it
  Point2D C;
  Point2D D;
  Point2D[] SQ;

  D = new Point2D(10,10);
  C = new Point2D(10,10);
  SQ = new Point2D[4];
  SQ[0] = A;
  SQ[1] = B;
  SQ[2] = C;
  SQ[3] = D;
  
  return(new Polygon2D( 4, SQ));
}*/

void carpet(Point2D A, Point2D B, float depth){ // recursive method
  Point2D C;
  Point2D D;
  Point2D E;
  Point2D F;
  Point2D G;
  Point2D H;
  
  float u0 = ( B.x - A.x), u1 = ( B.y - A.y);

  Square2D bigSquare;
  Square2D smallSquare;
    
        
  C = new Point2D(-u1  + A.x + u0, u0 + A.y + u1);
  D = new Point2D(-u1 + A.x, u0 + A.y);
  
  
  
  bigSquare = new Square2D ( A, B, C, D);
  
  
  //stroke(210,20,30,50);
  //fill(255-150*(depth),255-150*(depth),255-150*(depth));
  fill(0,0,255-100*(depth));
  
   noFill();
   stroke(0,0,255-150*(depth));
  //bigSquare.displayFill();
   bigSquare.displayLines();
  
  
  
  
  
  
  E = new Point2D(A.x+ u0/3, A.y+ u0/3);
  F = new Point2D(A.x+ 2*u0/3,  A.y+ u0/3);
  
  G = new Point2D(-u1/3  + E.x + u0/3, u0/3 + E.y + u1/3);
  H = new Point2D(-u1/3 + E.x, u0/3 + E.y);;
  
  
  //smallSquare= new Square2D (E,F,G,H  );
  
 
  
  //println (E.x +", "+ E.y);
  
  
  
  
  //fill(255);
  //stroke(0);
  //smallSquare.display();
 // smallSquare.displayFill();


  
  
  if (depth > 1){
     depth = depth-1;
     carpet(E, F, depth);
     
     E = new Point2D(A.x, A.y);
     F = new Point2D(A.x+ u0/3,  A.y);
     carpet(E, F, depth);
     
    
     
     
     E = new Point2D(A.x+2*u0/3, A.y);
     F = new Point2D(A.x+ u0,  A.y);
     carpet(E, F, depth);
     
     
     E = new Point2D(A.x, A.y+2*u0/3);
     F = new Point2D(A.x+ u0/3,  A.y +2*u0/3);
     carpet(E, F, depth);
     
     E = new Point2D(A.x+2*u0/3, A.y+2*u0/3);
     F = new Point2D(A.x+ u0,  A.y+2*u0/3);
     carpet(E, F, depth);
     
     
     
     
     
     
     
    
  }
}

float espejoVertical(float y){  return( height-y );}















/*************** START LIBRARY OF CLASSES ***************/


class Point2D
{ 
  float x;
  float y;
  
  Point2D (float X,float Y){  
    x = X;
    y = Y;
  }
  void display(){
    ellipseMode(CENTER_RADIUS);
    ellipse(x, y, 2, 2);
  }
}


class Triangle2D
{	
	Point2D A, B, C;
	Triangle2D (Point2D A, Point2D B, Point2D C){ // constructor
	  this.A = A;
	  this.B = B;
	  this.C = C;
	} // closes method
        Triangle2D (float x1, float y1, float x2, float y2, float x3, float y3){ // constructor
	  this.A = new Point2D(x1,y1);
	  this.B = new Point2D(x2,y2);
	  this.C = new Point2D(x3,y3);
	} // closes method
        void display(){
          line(A.x, A.y, B.x, B.y);
          line(B.x, B.y, C.x, C.y);
          line(C.x, C.y, A.x, A.y);
          A.display();
          B.display();
          C.display();
        }
         void displayLines(){
          line(A.x, A.y, B.x, B.y);
          line(B.x, B.y, C.x, C.y);
          line(C.x, C.y, A.x, A.y);
        }
         void displayPoints(){
          A.display();
          B.display();
          C.display();
        }
        void displayFill(){
          triangle(A.x, A.y, B.x, B.y, C.x, C.y);
        }
}


class Square2D
{	
	Point2D A, B, C, D;
	Square2D (Point2D A, Point2D B, Point2D C, Point2D D){ // constructor
	  this.A = A;
	  this.B = B;
	  this.C = C;
          this.D = D;
	} // closes method
        Square2D (float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4){ // constructor
	  this.A = new Point2D(x1,y1);
	  this.B = new Point2D(x2,y2);
	  this.C = new Point2D(x3,y3);
          this.D = new Point2D(x4,y4);
	} // closes method
        void display(){
          line(A.x, A.y, B.x, B.y);
          line(B.x, B.y, C.x, C.y);
          line(C.x, C.y, D.x, D.y);
          line(D.x, D.y, A.x, A.y);
          A.display();
          B.display();
          C.display();
          D.display();
        }
         void displayLines(){
          line(A.x, A.y, B.x, B.y);
          line(B.x, B.y, C.x, C.y);
          line(C.x, C.y, D.x, D.y);
          line(D.x, D.y, A.x, A.y);
        }
         void displayPoints(){
          A.display();
          B.display();
          C.display();
          D.display();
        }
        void displayFill(){
          triangle(A.x, A.y, B.x, B.y, C.x, C.y);
          triangle(A.x, A.y, C.x, C.y, D.x, D.y);
        }
}

 
class Vector2D
{	
	Point2D A;
        float angle, magnitude;
	Vector2D (Point2D A, float angle, float magnitude){ // constructor
	  this.A = A;
	  this.angle = angle;
	  this.magnitude = magnitude;
	} // closes method
        Vector2D (float x,float y, float angle, float magnitude){ // constructor
	  this.A = new Point2D(x,y);
	  this.angle = angle;
	  this.magnitude = magnitude;
	} // closes method
        void display(){          
          line(A.x, A.y, A.x + ( magnitude * sin(angle) ), A.y + ( magnitude * cos(angle) ) );
          A.display();         
        }
        void displayEnd(){
          Point2D B;
          B = new Point2D(A.x + ( magnitude * sin(angle) ), A.y + ( magnitude * cos(angle) ) );
          B.display();        
        }
        Point2D startPoint(){
          return (A);
        }
        Point2D endPoint(){
          Point2D B;
          B = new Point2D(A.x + ( magnitude * sin(angle) ), A.y + ( magnitude * cos(angle) ) );
          return (B);
        }
}  


class Polygon2D
{	int vertices;
	Point2D[] A;
       
       
	Polygon2D (int vertices, Point2D[ ]A ){ // constructor
	  this.vertices = vertices;
          this.A = new Point2D[vertices];
          for (int i = 0; i < vertices; i++){
            this.A[i] = A[i];
                             
          }                   
	} // closes method

        void display(){
          for (int i = 0; i < vertices; i++){
           
            int k = (i + 1) % (vertices);         
            line(A[i].x, A[i].y, A[k].x , A[k].y  );
            A[i].display();        
          } 
        }
        void displayFill(){ // work it out this one
         
        }
} 

















/*************** METHODS ***************/

Point2D midPoint(Point2D X,Point2D Y){
  Point2D mid;
  mid = new Point2D( X.x +( (Y.x-X.x)/2 ), X.y +( (Y.y-X.y)/2 ) ); // fun to change any of this 2 for a 3
  return (mid);
}


Point2D randomChoice(Point2D X, Point2D Y, Point2D Z){
  float r = random(0,3);
  Point2D rand;
  
  if (r < 1f)
    rand = new Point2D( Y.x, Y.y );
  else{
    if(r < 2f) 
      rand = new Point2D( X.x, X.y );
    else
      rand = new Point2D( Z.x, Z.y );
  }
  return (rand);
}


Point2D randomPoint(){
  float rx = random(0,1);
  float ry = random(0,1);
  Point2D rand;
  
  
   rand = new Point2D( width * rx, height * ry );
  
  return (rand);
}


float area2(Point2D A, Point2D B, Point2D C)
{
  return (A.x - C.x) * (B.y - C.y) - (A.y - C.y) * (B.x - C.x);
}
	
boolean insideTriangle(Point2D A, Point2D B, Point2D C,  Point2D P){
	// ABC is assumed to be c ounterclockwise
  return
	area2(A, B ,P ) >= 0 &&
	area2(B, C, P) >= 0 &&
	area2(C, A, P) >= 0; 
}
	
void triangulate (Point2D[] P,Triangle2D[] tr)
{
  // P contains all n polygon vertices in ccw order
  // the resulting triangles will be stored in array tr
  // this array tr must have lenght n-2
	
  int n = P.length, j = n - 1, iA = 0, iB, iC;
  int[] next = new int[n];
  for (int i= 0; i < n; i++)
  {	next[j] = i;
	j = i;
  }
  for (int k = 0; k < n-2; k++)
  {	// find a suitable triangle consisting of
	// two edges and an internal diagonal
	Point2D A, B, C;
	boolean triaFound = false;
	int count = 0;
	while (!triaFound && ++count < n)
	{	iB = next[iA];
		iC = next[iB];
		A = P[iA];
		B = P[iB];
		C = P[iC];
		if(area2(A, B, C) >= 0)
		{	// edges AB and BC, diagonal AC
			// test to see if no other polygon vertex
			// lies within triangle ABC:
			j = next[iC];
			while( j != iA && !insideTriangle(A, B, C, P[j]))
				j = next[j];
			if ( j == iA)
			{	// then triangle ABC contains no other vertex:
				tr[k] = new Triangle2D(A, B, C);
				next[iA] = iC;
				triaFound = true;
			}
		}
		iA = next[iA];
	}
	if (count == n)
	{	println("not a simple polygon" +
		" or vertex sequence not counterclockwise");
		
	}	
  }
}

float distance2(Point2D P, Point2D Q)
{	float	dx = P.x = Q.x, dy = P.y = Q.y;
	return dx * dx + dy * dy;
}