/*

   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>

*/

Circle[] cc;

void setup()
{
  size( 600, 600 );
  framerate( 30 );
  cc = new Circle[100];
  for (int i=0; i<cc.length; i++) {
    cc[i] = new Circle( random(width), random(height), 15+random(20), i );
  }
  ellipseMode(CENTER_DIAMETER);
  rectMode(CENTER_DIAMETER);
  noFill();
}

void loop()
{
  background(255);

  noStroke();
  fill(0);

  for (int i=0; i<cc.length; i++) {
    cc[i].draw();
  }

  noFill();
  stroke(255);

  for (int i=0; i<cc.length; i++) {
    cc[i].drawHair();
  }
}

class Circle {

  float x, y, r, r2, d, d2;
  float lastx, lasty;

  float ac1, ac2, ac3;
  float sp1, sp2, sp3;

  float inx = 0;
  float iny = 0;

  boolean hasIntersect = false;
  Hair[] hairs;

  int gray;

  int id;

  Circle( float px, float py, float pr, int id ) {
    x = px;
    y = py;
    r = pr;
    r2 = r*r;
    d = r*2;
    d2 = d*d;

    this.id = id;

    gray = 0;

    hairs = new Hair[30];
    float stepA =  2*PI/hairs.length;;
    for (int i=0; i<hairs.length; i++) {

      hairs[i] = new Hair( cos(stepA*i)*r, sin(stepA*i)*r, 5, stepA*i+PI, this );
    }

    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() {
    ellipse(x, y, d, d);
    move();
  }

  void drawHair() {

    for (int i=0; i<hairs.length; i++) {
      hairs[i].updatePos();
      hairs[i].draw();
    }
  }

  void move() {
    float angle = sin( sp1 ) - cos(sp2);

    sp1+=ac1;
    sp2+=ac2;
    sp3+=ac3;

    angle = (angle<0) ? angle+TWO_PI : ( (angle>=TWO_PI) ? angle-TWO_PI : angle );

    x += sin(angle);
    y -= cos(angle);

    checkBounds();

    checkIntersect();

  }

  void checkIntersect() {

    boolean flag = false;
    boolean flag2 = false;
    for (int i=0; i<cc.length; i++) {
      if (i!=id) {
        flag = intersect( cc[i]);
        if (!flag2) flag2 = flag;
      }
    }

    if (flag2) {
      hairFocus(inx, iny);
    } else if ( hasIntersect ) {
      hairFocus();
    }

    hasIntersect = flag2;

  }

  boolean intersect( Circle cB ) {

    float dx = x - cB.x;
    float dy = y - cB.y;
    float d2 = dx*dx + dy*dy;
    float d = sqrt( d2 );

    if ( d>r+cB.r || d<abs(r-cB.r) ) return false;

    float a = (r2 - cB.r2 + d2) / (2*d);
    float h = sqrt( r2 - a*a );
    float x2 = x + a*(cB.x - x)/d;
    float y2 = y + a*(cB.y - y)/d;

    float paX = x2 + h*(cB.y - y)/d;
    float paY = y2 - h*(cB.x - x)/d;
    //float pbX = x2 - h*(cB.y - y)/d;
    //float pbY = y2 + h*(cB.x - x)/d;

    repel( atan2( dy, dx) );

    ellipse( paX, paY, 15, 15 );
    //ellipse( pbX, pbY, 20, 20 );

    //if ( cB.id > id ) {
      inx = x2;
      iny = y2;

    //} else {
      //inx = pbX;
      //iny = pbY;
    //}

    return true;

  }

  void repel( float angle ) {
    x = x + cos(angle)/4;
    y = y + sin(angle)/4;

  }

  void hairFocus( float px, float py) {

    for (int i=0; i<hairs.length; i++) {
      hairs[i].focus( px, py );
    }

  }

  void hairFocus() {
    for (int i=0; i<hairs.length; i++) {
      hairs[i].revertFocus();
    }
  }

  void checkBounds() {
    //x = Math.min( width, Math.max( 0, x ) );
    //y = Math.min( height, Math.max( 0, y ) );

    if ( x > width ) x = 0;
    if ( x < 0 ) x = width;
    if ( y > height ) y = 0;
    if ( y < 0 ) y = height;

  }

}

class Hair {

  float repel_speed;

  float radius, origRadius;
  float angle, origAngle;
  float x, y, regX, regY, nextX, nextY, lastx, lasty;

  float speedFactor = 5;

  Circle parent;

  Hair( float rx, float ry, float r, float a, Circle parent ) {
    radius = r;
    origRadius = r;

    angle = a;
    origAngle = a;

    this.parent = parent;

    regX = rx;
    regY = ry;

    nextX = parent.x+regX+cos(angle)*radius;
    nextY = parent.y+regY+sin(angle)*radius;

    x = nextX;
    y = nextY;

  }

  void updatePos() {

    nextX = parent.x+regX+cos(angle)*radius;
    nextY = parent.y+regY+sin(angle)*radius;

    float dx = nextX - x;
    float dy = nextY - y;
    if (abs(dx)>1) {
      x += dx/speedFactor;
      y += dy/speedFactor;
    }

    if (abs(dx)>200 || abs(dy)>200) {
      x = nextX;
      y = nextY;
    }

  }

  void draw() {
    line( parent.x+regX, parent.y+regY, x, y );

  }

  void focus( float px, float py ) {
    float dx = px-(parent.x+regX);
    float dy = py-(parent.y+regY);

    angle = atan2( dy, dx );
    radius = dist( px, py, parent.x+regX, parent.y+regY );
  }

  void revertFocus() {
    angle = origAngle;
    radius = origRadius;
  }
}