/* 
   
   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 J. Tarbell <http://levitated.net> 
   8 April 2004 
   Processing v.68 <http://processing.org> 
   
*/ 
 
// widthensions 
int num = 100; 
int time = 0; 
 
// display flag 
boolean showStructure = false; 
 
// object array 
Disc[] discs; 
 
 
// methods 
void setup() { 
  size(500, 500); 
  colorMode(RGB,255); 
  ellipseMode(CENTER_RADIUS); 
  background(0); 
  framerate(30); 
  
  // make 100 discs 
  discs = new Disc[num]; 
 
  // arrange linearly 
  for (int i=0;i<num;i++) { 
    float x = random(width); 
    float y = random(width); 
    float fy = 0; 
    float fx = random(-1.0,1.0); 
    float r = 20+random(20); 
    
    discs[i] = new Disc(i,x,y,fx,fy,r); 
  } 
} 
 
// main 
void loop() { 
  if (showStructure) { 
    background(0); 
    // render circles and intersections 
    for (int c=0;c<num;c++) { 
      discs[c].draw(); 
    } 
  } 
  // move discs 
  for (int c=0;c<num;c++) { 
    discs[c].move(); 
    discs[c].render(); 
  } 
  time++; 
} 
 
void keyReleased () { 
  if (key==' ') { 
    background(0); 
    if (showStructure) { 
      showStructure = false; 
    } else { 
      showStructure = true; 
    } 
  } 
} 
 
// translucent point 
void tpoint(int x1, int y1, int gc, float a) { 
  noStroke(); 
  fill(gc,a*255); 
  rect(x1,y1,1,1); 
} 
 
 
// disc object 
class Disc { 
  // index identifier 
  int id; 
  // position 
  float x,y; 
  // radius 
  float r, dr; 
  // velocity 
  float vx,vy; 
 
  // sand painters 
  int numsands = 1; 
  SandPainter[] sands = new SandPainter[numsands]; 
 
  Disc(int Id, float X, float Y, float Vx, float Vy, float R) { 
    // construct 
    id=Id; 
    x=X; 
    y=Y; 
    vx=Vx; 
    vy=Vy; 
    dr=R; 
    r=1.0; 
    
    // create sand painters 
    for (int n=0;n<numsands;n++) { 
      sands[n] = new SandPainter(); 
    } 
  } 
 
  void draw() { 
    stroke(64); 
    noFill(); 
    ellipse(x,y,r,r); 
  } 
 
  void render() { 
    // find intersecting points with all ascending discs 
    for (int n=id+1;n<num;n++) { 
      // find distance to other disc 
      float dx = discs[n].x-x; 
      float dy = discs[n].y-y; 
      float d = sqrt(dx*dx+dy*dy); 
      // intersection test 
      if (d<(discs[n].r+r)) { 
        // complete containment test 
        if (d>abs(discs[n].r-r)) { 
          // find circle intersection solutions 
          float a = (r*r - discs[n].r*discs[n].r + d*d ) / (2*d); 
          
          float p2x = x + a*(discs[n].x - x)/d; 
          float p2y = y + a*(discs[n].y - y)/d; 
          
          float h = sqrt(r*r - a*a); 
          
          float p3ax = p2x + h*(discs[n].y - y)/d; 
          float p3ay = p2y - h*(discs[n].x - x)/d; 
          
          float p3bx = p2x - h*(discs[n].y - y)/d; 
          float p3by = p2y + h*(discs[n].x - x)/d; 
          // P3a and P3B may be identical - ignore this case (for now) 
 
          if (showStructure) { 
            stroke(255); 
            point(p3ax,p3ay); 
            point(p3bx,p3by); 
          } else { 
            tpoint(int(p3ax-1),int(p3ay),255,0.21); 
            tpoint(int(p3ax+1),int(p3ay),0,0.21); 
            tpoint(int(p3bx-1),int(p3by),255,0.21); 
            tpoint(int(p3ax+1),int(p3ay),0,0.21); 
          } 
          // draw sand painters 
          for (int s=0;s<numsands;s++) { 
            sands[s].render(p3ax,p3ay,p3bx,p3by); 
          } 
        } 
      } 
    } 
  } 
 
  void move() { 
    // move radius towards destination radius 
    if (r<dr) r+=0.02; 
    // add velocity to position 
    x+=vx; 
    y+=vy; 
    // bound check 
    if (x+r<0) { 
      x+=width+r+r; 
      y=random(width); 
    } 
    if (x-r>width) { 
      x-=width+r+r; 
      y=random(width); 
     } 
    if (y+r<0) { 
      y+=width+r+r; 
      x=random(width); 
    } 
    if (y-r>width) { 
      y-=width+r+r; 
      x=random(width); 
    } 
  } 
  
} 
 
// sandpainter object 
class SandPainter { 
 
  float p; 
  float g; 
  int c; 
 
  SandPainter() { 
    p = random(1.0); 
    c = int(random(256)); 
    g = random(0.01,0.1); 
  } 
 
  void render(float x, float y, float ox, float oy) { 
    // draw painting sweeps 
    tpoint(int(ox+(x-ox)*sin(p)),int(oy+(y-oy)*sin(p)),c,0.11); 
 
    g+=random(-0.050,0.050); 
    float maxg = 0.5; 
    if (g<-maxg) g=-maxg; 
    if (g>maxg) g=maxg; 
    p+=random(-0.050,0.050); 
    if (p<0) p=0; 
    if (p>1.0) p=1.0; 
 
    float w = g/10.0; 
    for (int i=0;i<11;i++) { 
      tpoint(int(ox+(x-ox)*sin(p + sin(i*w))),int(oy+(y-oy)*sin(p + sin(i*w))),c,0.1-i/110); 
      tpoint(int(ox+(x-ox)*sin(p - sin(i*w))),int(oy+(y-oy)*sin(p - sin(i*w))),c,0.1-i/110); 
    } 
  } 
}