/* 
 
   Structure 3 (work in progress) 
   
   A surface filled with one hundred medium to small sized circles. 
   Each circle has a different size and direction, but moves at the same slow rate. 
   Display: 
   A. The instantaneous intersections of the circles 
   B. The aggregate intersections of the circles 
 
   Implemented by Casey Reas <http://groupc.net> 
   Uses circle intersection code from William Ngan <http://metaphorical.net> 
   Processing v.68 <http://processing.org> 
 
*/ 
 
 
Circle circleA, circleB; 
 
void setup() 
{ 
  size( 300, 300 ); 
  framerate( 30 ); 
 
  circleA = new Circle( 150, 150, 60 ); 
  circleB = new Circle( 150, 150, 90 ); 
 
  ellipseMode(CENTER_DIAMETER); 
  rectMode(CENTER_DIAMETER); 
  noStroke(); 
} 
 
 
void loop() 
{ 
  circleA.update(); 
  circleB.update(); 
  intersect( circleA, circleB ); 
} 
 
 
class Circle 
{ 
  float x, y, r, r2; 
  float xspeed, xdir; 
  float yspeed, ydir; 
 
  Circle( float px, float py, float pr ) { 
    x = px; 
    y = py; 
    r = pr; 
    r2 = r*r; 
    xspeed = random(-2.0, 2.0); 
    yspeed = random(-2.0, 2.0); 
    xdir = 1; 
    ydir = -1; 
  } 
  
  void update() { 
  
    x += xspeed * xdir; 
    if(x > width - r || x < r) { 
      xdir = xdir * -1; 
    } 
    
    y += yspeed * ydir; 
    if(y > width - r || y < r) { 
      ydir = ydir * -1; 
    } 
    
  } 
} 
 
void intersect( Circle cA, Circle cB ) { 
 
  float dx = cA.x - cB.x; 
  float dy = cA.y - cB.y; 
  float d2 = dx*dx + dy*dy; 
  float d = sqrt( d2 ); 
 
  if ( d>cA.r+cB.r || d<abs(cA.r-cB.r) ) return; // no solution 
  
  float a = (cA.r2 - cB.r2 + d2) / (2*d); 
  float h = sqrt( cA.r2 - a*a ); 
  float x2 = cA.x + a*(cB.x - cA.x)/d; 
  float y2 = cA.y + a*(cB.y - cA.y)/d; 
 
  stroke(0, 0, 0, 26); 
 
  float paX = x2 + h*(cB.y - cA.y)/d; 
  float paY = y2 - h*(cB.x - cA.x)/d; 
  float pbX = x2 - h*(cB.y - cA.y)/d; 
  float pbY = y2 + h*(cB.x - cA.x)/d; 
 
  line(paX, paY, pbX, pbY); 
 
}