/*

   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>

*/

int num = 100;
int time = 0;

// object array
Disc[] discs;

// initialization
void setup() {
  size(500, 500);
  colorMode(RGB,255);
  ellipseMode(CENTER_RADIUS);
  background(0);
  framerate(30);

  // make some discs
  discs = new Disc[num];

  // arrange in anti-collapsing circle
  for (int i=0;i<num;i++) {
    float fx = 0.4*width*cos(TWO_PI*i/num);
    float fy = 0.4*width*sin(TWO_PI*i/num);
    float x = random(width/2) + fx;
    float y = random(width/2) + fy;
    float r = 5+random(45);
    int bt = 1;
    if (random(100)<50) bt=-1;
    discs[i] = new Disc(i,x,y,bt*fx/1000.0,bt*fy/1000.0,r);
  }
}

// main
void loop() {
  background(0);
  // move discs
  for (int c=0;c<num;c++) {
    discs[c].move();
    discs[c].render();
    discs[c].renderPxRiders();
  }
  time++;
}

// disc object
class Disc {
  // index identifier
  int id;
  // position
  float x,y;
  // radius
  float r, dr;
  // velocity
  float vx,vy;

  //  pixel riders
  int numr;
  int maxr = 40;
  PxRider[] pxRiders;

  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=0;

    numr = int(R/1.62);
    if (numr>maxr) numr=maxr;

    // create pixel riders
    pxRiders = new PxRider[maxr];
    for (int n=0;n<maxr;n++) {
      pxRiders[n] = new PxRider();
    }
  }

  void draw() {
    stroke(0,50);
    noFill();
    ellipse(x,y,r,r);
  }

  void render() {
    // find intersecting points with all ascending discs
    for (int n=id+1;n<num;n++) {
      if (n!=id) {
      // 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 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)
          stroke(255);
          point(p3ax,p3ay);
          point(p3bx,p3by);
        }
      }
      }
    }
  }

  void move() {
    // add velocity to position
    x+=vx;
    y+=vy;
    // bound check
    if (x+r<0) x+=width+r+r;
    if (x-r>width) x-=width+r+r;
    if (y+r<0) y+=width+r+r;
    if (y-r>width) y-=width+r+r;

    // increase to destination radius
    if (r<dr) {
      r+=0.1;
    }
  }

  void renderPxRiders() {
    for (int n=0;n<numr;n++) {
      pxRiders[n].move(x,y,r);
    }
  }

  // pixel rider object
  class PxRider {
    float t;
    float vt;
    int mycharge;

    PxRider() {
      t=random(TWO_PI);
      vt=0.0;
    }

    void move(float x, float y, float r) {
      // add velocity to theta
      t=(t+vt+PI)%TWO_PI - PI;

      vt+=random(-0.001,0.001);

      // apply friction brakes
      if (abs(vt)>0.02) vt*=0.9;

      // draw
      float px = x+r*cos(t);
      float py = y+r*sin(t);
      color c = get(int(px),int(py));
      if (brightness(c)>48) {
        glowpoint(px,py);
        mycharge = 164;
      } else {
        stroke(mycharge);
        point(px,py);
        mycharge*=0.98;
      }

    }
  }
}


// methods
void glowpoint(float px, float py) {
  for (int i=-2;i<3;i++) {
    for (int j=-2;j<3;j++) {
      float a = 0.8 - i*i*0.1 - j*j*0.1;
      tpoint(int(px+i),int(py+j),#FFFFFF,a);
    }
  }
}

void tpoint(int x1, int y1, color myc, float a) {
  // place translucent point
  int r, g, b;
  color c;

  c = get(x1, y1);

  r = int(red(c) + (red(myc) - red(c)) * a);
  g = int(green(c) +(green(myc) - green(c)) * a);
  b = int(blue(c) + (blue(myc) - blue(c)) * a);
  color nc = color(r, g, b);
  stroke(nc);
  point(x1,y1);
}