/* 
   
   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 William Ngan <http://metaphorical.net> 
   4 April 2004 
   Processing v.68 <http://processing.org> 
 
*/ 
 
 
float[][] field; 
int[][] fieldShade; 
int gaph, gapv; 
int marginh, marginv; // margin 
float cnt = 0; 
 
float[] sintable = new float[628]; 
float[] costable = new float[628]; 
final float PI2 = 2*PI; 
float tiltAngle = 0; 
 
Circle[] circles; 
 
float counter = 0; 
 
int cCounter = 0; 
int cTimer = 0; 
 
void setup() 
{ 
  size( 500, 500 ); 
  framerate( 30 ); 
 
  gaph = 3; 
  gapv = 3; 
  marginh = 20; 
  marginv = 20; 
 
  // lookup table 
  for (int i=0; i<sintable.length; i++) { 
    sintable[i] = sin( i/100.0f ); 
  } 
 
  for (int i=0; i<costable.length; i++) { 
    costable[i] = cos( i/100.0f ); 
  } 
 
  // field 
  field = new float[(width-marginh*2)/gaph][(height-marginv*2)/gapv]; 
  fieldShade = new int[field.length][field[0].length]; 
 
  for (int i=0; i<field.length; i++) { 
    for (int k=0; k<field[0].length; k++) { 
      field[i][k] = PI2-PI/3; 
      fieldShade[i][k] = 1; 
    } 
  } 
 
  circles = new Circle[100]; 
 
  ellipseMode( CENTER_DIAMETER ); 
  noFill(); 
} 
 
void loop() 
{ 
  background( 50 ); 
  stroke(255,255,255,50); 
 
  int ax, ay; 
  cTimer++; 
  if (cTimer>5 && cCounter<circles.length-1) { 
    circles[cCounter] = new Circle( 250, 250, 40, cCounter ); 
    cCounter++; 
    cTimer = 0; 
  } 
 
  float len = 10; 
 
  for (int i=0; i<field.length; i++) { 
    for (int k=0; k<field[0].length; k++) { 
      ax = marginh + i*gaph; 
      ay = marginv + k*gapv; 
      line( ax, ay, ax+len*getCos(field[i][k]), ay+len*getSin(field[i][k]) ); 
    } 
  } 
 
  noStroke(); 
  noFill(); 
 
  for (int i =0; i<cCounter; i++) { 
    circles[i].draw(); 
    circles[i].getGrid(); 
  } 
 
} 
 
int[] getLocation( int i, int k ) 
{ 
return new int[]{ marginh+i*gaph, marginv+k*gapv }; 
} 
 
float getSin( float val ) 
{ 
  if (val<0) val = 6.28 + val; 
  if (val>=6.28) val -= 6.28; 
  val = min( 6.27, max( 0, val ) ); 
  return sintable[ (int)floor(val*100) ]; 
} 
 
float getCos( float val ) 
{ 
  if (val<0) val = 6.28 + val; 
  if (val>=6.28) val -= 6.28; 
  val = min( 6.27, max( 0, val ) ); 
 
  return costable[ (int)floor(val*100) ]; 
} 
 
class Circle 
{ 
  float x, y, r, d, rr; 
  float ac1, ac2, ac3; 
  float sp1, sp2, sp3; 
  int id; 
 
  float inx = 0; 
  float iny = 0; 
  boolean over = true; 
 
  Circle( float px, float py, float pr, int id ) { 
    x = px; 
    y = py; 
    r = pr; 
    d = r*2; 
    rr = r*r; 
 
    this.id = id; 
 
    sp1 = random(2); 
    sp2 = random(2); 
    sp3 = random(2); 
 
    ac1 = random(0.5)-random(0.5); 
    ac2 = random(0.5)-random(0.5); 
    ac3 = random(0.5)-random(0.5); 
 
  } 
 
  void draw() { 
    move(); 
    ellipse( x, y, d, d ); 
  } 
 
  void move() { 
    float angle = sin( sp1 ) - cos(sp2); 
 
    sp1+=ac1; 
    sp2+=ac2; 
    sp3+=ac3; 
 
    angle = (angle<0) ? angle+PI2 : ( (angle>=PI2) ? angle-PI2 : angle ); 
 
    x = x + getSin(angle); 
    y = y + getCos(angle); 
 
    checkBounds(); 
    checkOverlap(); 
 
  } 
 
  void checkBounds() { 
    if ( x > width ) x = 0; 
    if ( x < 0 ) x = width; 
    if ( y > height ) y = 0; 
    if ( y < 0 ) y = height; 
  } 
 
  void repel( float angle ) { 
    x = x + getCos(angle)/10; 
    y = y + getSin(angle)/10; 
  } 
 
  void setState( float px, float py ) { 
    inx = px; 
    iny = py; 
    over = true; 
  } 
 
  void checkOverlap() { 
 
    for ( int i=id+1; i<cCounter; i++ ) { 
      if ( i!=id ) { 
        float dx = circles[i].x - x; 
        float dy = circles[i].y - y; 
        float drr = dx*dx + dy*dy; 
        float brr = circles[i].rr + 2*circles[i].r*r + rr; 
        float d = sqrt( drr ); 
 
        if ( d>r+circles[i].r || d<abs(r-circles[i].r) ) continue; // no solution 
 
        float ang = atan2( dy, dx ); 
        repel( ang+PI ); 
        circles[i].repel( ang); 
 
        float a = (rr - circles[i].rr + drr) / (2*d); 
        float h = sqrt( rr - a*a ); 
        float x2 = x + a*(circles[i].x - x)/d; 
        float y2 = y + a*(circles[i].y - y)/d; 
 
        setState( x2, y2 ); 
        circles[i].setState( x2, y2 ); 
      } 
    } 
  } 
 
  void getGrid() { 
 
    int sx = (int)ceil((x-r-marginh)/gaph); 
    int sy = (int)ceil((y-r-marginv)/gapv); 
 
    int numx = (int)floor(d/gaph); 
    int numy = (int)floor(d/gapv); 
 
    int[] pos; 
    float dx, dy, ang; 
 
    for (int i=sx; i<sx+numx; i++) { 
      if (i>=0 && i<field.length) { 
        for (int k=sy; k<sy+numy; k++) { 
          if (k>=0 && k<field[0].length) { 
            if (over) { 
              pos = getLocation(i, k); 
              dx = pos[0]-x; 
              dy = pos[1]-y; 
 
              if (dist( x, y, pos[0], pos[1]) < r) { 
                float da = atan2( pos[1]-iny, pos[0]-inx ); 
                if (field[i][k] < da) field[i][k] += PI/20; 
                else if (field[i][k] > da) field[i][k] -= PI/20; 
                fieldShade[i][k] = 2; 
              } 
            } 
          } 
        } 
      } 
    } 
    over = false; 
  } 
}