import java.awt.*;
import java.lang.Math;
import java.util.Random;


public class swarm
extends java.applet.Applet
implements Runnable
{
  Thread runner;
  Image offscreenImg;
  Graphics offscreen;
  Canvas canvas;
  Label Nlabel, esizelabel, speedlabel, scalelabel, noiselabel, epslabel;
  TextField Ntf, esizetf, speedtf, scaletf, noisetf, epstf;
  Choice areaGeometry;
  int areageom = 1;

  int maxN = 100;

  int numcolors = 64;
  Color colortab[] = new Color[numcolors];
  int colorindex[] = new int[maxN];

  int sleeptime = 25; // Milliseconds


  double speed = .01;
  double scale = .045;
  double noise = 1;
  double eps   = 4;

  int elemSize = 4;

  int width, height;
  int canvas_width;
  int canvas_height;


  int N = 40;
  double xp[] = new double[maxN],
         yp[] = new double[maxN],
         vx[] = new double[maxN],
	 vy[] = new double[maxN],
	 vqx[] = new double[maxN],
         vqy[] = new double[maxN];



  public void init()
  {
    int i;
    Random r = new Random();
    double v;

    for (i=0; i<numcolors; i++)
      colortab[i] = Color.getHSBColor( (float)Math.sin( 1.5708 *i/(numcolors)),
                1.F, 1.F );



    width = size().width;
    height = size().height;

    canvas_width = width - 10;
    canvas_height = height - 80;

    setLayout( new FlowLayout() );

    canvas = new Canvas();
    canvas.setBackground(Color.white);
    canvas.resize( canvas_width, canvas_height );
    add(canvas);

    offscreenImg = createImage( canvas_width, canvas_height );
    offscreen    = offscreenImg.getGraphics();

    add( new Button("init") );

    
    areaGeometry = new Choice();
    areaGeometry.addItem("Rectangle");
    areaGeometry.addItem("Ellipse");
  //  areaGeometry.addItem("Triangle");
    add(areaGeometry);

    Nlabel = new Label( "N", Label.RIGHT );
    add(Nlabel);
    Ntf = new TextField( Integer.toString( N ) );
    add(Ntf);

    esizelabel = new Label( "size", Label.RIGHT );
    add(esizelabel);
    esizetf = new TextField( Integer.toString( elemSize ) );
    add(esizetf);

    speedlabel = new Label( "speed", Label.RIGHT );
    add(speedlabel);
    speedtf = new TextField( Double.toString( speed ) );
    add(speedtf);

    scalelabel = new Label("scale", Label.RIGHT);
    add(scalelabel);
    scaletf = new TextField( Double.toString( scale ));
    add(scaletf);

    noiselabel = new Label("noise", Label.RIGHT);
    add(noiselabel);
    noisetf = new TextField( Double.toString( noise ));
    add(noisetf);

    epslabel = new Label("coupling", Label.RIGHT);
    add(epslabel);
    epstf = new TextField( Double.toString( eps ) );
    add(epstf);

    // initial to random positions and directions

    for (i=0; i<maxN; i++)
    {
      xp[i] = .5;
      yp[i] = .5;
      vx[i] = r.nextDouble()-.5;
      vy[i] = r.nextDouble()-.5;
      v = Math.sqrt(vx[i]*vx[i]+vy[i]*vy[i])+1e-10;
      vx[i] /= v;
      vy[i] /= v;
    }
  }

  public void start()
  {
    if (runner == null)
    {
      runner = new Thread(this);
      runner.start();
    }
  }

  public void stop()
  {
    if (runner != null)
    {
      runner = null;
    }
  }

  public void run()
  {
    int i,j;
    Random r = new Random();
    double vq, dist, dx, dy, fac;

    Thread thisThread = Thread.currentThread();
    while (runner == thisThread)
    {

      // compute new velocities

      for (i=0; i<N; i++)
      {
        for(j=0, vqx[i]=0, vqy[i]=0; j<N; j++)
	{
	  dx = xp[i]-xp[j];
	  dy = yp[i]-yp[j];
//	  dist = Math.sqrt( dx*dx + dy*dy )/scale;
//	  dist = dist*dist;
//	  fac = Math.exp(-dist);
          if (dx*dx + dy*dy < scale*scale)
	    fac=1;
          else
	    fac=0;
	  vqx[i] += fac*vx[j];
	  vqy[i] += fac*vy[j];
	}
      }
      
      for (i=0; i<N; i++)
      {
        vx[i] += (eps*vqx[i]/N + noise*(r.nextDouble()-.5));
        vy[i] += (eps*vqy[i]/N + noise*(r.nextDouble()-.5));
        vq = Math.sqrt( vx[i]*vx[i]+vy[i]*vy[i] );
	vx[i] /= vq;
	vy[i] /= vq;
      }


      // compute new positions

      for (i=0; i<N; i++)
      {
        xp[i]+=speed*vx[i];
	yp[i]+=speed*vy[i];
      }
 
      // bounce at borders

      double xBorderWidth = elemSize/(double)canvas_width,
             yBorderWidth = elemSize/(double)canvas_height;

      if (areageom == 1)
      {
        for (i=0; i<N; i++)
        {
	  if (xp[i] < xBorderWidth && vx[i] < 0)
	    vx[i] *= -1;
	  if (xp[i] > 1.-xBorderWidth && vx[i] > 0)
	    vx[i] *= -1;
	  if (yp[i] < yBorderWidth && vy[i] < 0)
	    vy[i] *= -1;
	  if (yp[i] > 1.-yBorderWidth && vy[i] > 0)
	    vy[i] *= -1;
        }
      }
      else if (areageom == 2) // Ellipse
      {
        double x, y, radius, r2, delta, r1, vr, vphi;
	delta = .5*(xBorderWidth + yBorderWidth);
	r1 = .5-delta;
        for (i=0; i<N; i++)
        {
	  x = xp[i]-.5;
	  y = yp[i]-.5;
	  r2 = x*x+y*y;
	  radius = Math.sqrt(r2); // radial position of object
          if ( radius >= r1 )
	  {
            vr = x*vx[i] + y*vy[i];
	    if (vr > 0) // would move through border
	    {
              vx[i] -= 8*vr*x;
	      vy[i] -= 8*vr*y;
	    }
	  }
        }
      }
      else
      {
        // undefined geometry
	// ....
      }

      
      // compute new colors
      
      for (i=0; i<N; i++)
      {
        double phi = Math.abs( Math.atan(vy[i]/vx[i]) );
        colorindex[i] = (int)( numcolors*phi/1.5708);
	if (colorindex[i]>numcolors)
	 colorindex[i] = numcolors;
      }

      repaint();
      try
      {
        Thread.sleep( sleeptime );
      } catch (InterruptedException e) {}
    }
  }

  
  public boolean action(Event evt, Object arg)
  {
    if (evt.target instanceof TextField)
    {
      Double dval = new Double(0.);
      boolean numberFormatError;
      double newValue;


      numberFormatError = false;
      try
      {
        dval = Double.valueOf(Ntf.getText());
      }
      catch (NumberFormatException e)
      {
        numberFormatError = true;
      }
      if ( numberFormatError == false)
      {
        newValue = dval.doubleValue();
	if (newValue >=1. && newValue <= 100.)
	  N = (int)newValue;
      }

      numberFormatError = false;
      try
      {
        dval = Double.valueOf(esizetf.getText());
      }
      catch (NumberFormatException e)
      {
        numberFormatError = true;
      }
      if ( numberFormatError == false)
      {
        newValue = dval.doubleValue();
	if (newValue >=1. && newValue <= 100.)
	  elemSize = (int)newValue;
      }

      numberFormatError = false;
      try
      {
        dval = Double.valueOf(speedtf.getText());
      }
      catch (NumberFormatException e)
      {
        numberFormatError = true;
      }
      if ( numberFormatError == false)
      {
        newValue = dval.doubleValue();
	if (newValue >=0 && newValue <= 1)
	  speed = newValue;
      }
      
      numberFormatError = false;
      try
      {
        dval = Double.valueOf(scaletf.getText());
      }
      catch (NumberFormatException e)
      {
        numberFormatError = true;
      }
      if ( numberFormatError == false)
      {
        newValue = dval.doubleValue();
	if (newValue >=0 && newValue <= 100)
	  scale = newValue;
      }

      numberFormatError = false;
      try
      {
        dval = Double.valueOf(noisetf.getText());
      }
      catch (NumberFormatException e)
      {
        numberFormatError = true;
      }
      if ( numberFormatError == false)
      {
        newValue = dval.doubleValue();
	if (newValue >=0 && newValue <= 100)
	  noise = newValue;
      }
      
      numberFormatError = false;
      try
      {
        dval = Double.valueOf(epstf.getText());
      }
      catch (NumberFormatException e)
      {
        numberFormatError = true;
      }
      if ( numberFormatError == false)
      {
        newValue = dval.doubleValue();
	if (newValue >=0 && newValue <= 100)
	  eps = newValue;
      }

      return true;
    }
    else if (evt.target instanceof Button)
    {
      int i;
      Random r = new Random();
      double v;

      // initial to random positions and directions
      
      for (i=0; i<maxN; i++)
      {
        xp[i] = .5+.4*(r.nextDouble()-.5);
        yp[i] = .5+.4*(r.nextDouble()-.5);
        vx[i] = r.nextDouble()-.5;
        vy[i] = r.nextDouble()-.5;
        v = Math.sqrt(vx[i]*vx[i]+vy[i]*vy[i])+1e-10;
        vx[i] /= v;
        vy[i] /= v;
      }
      return true;
    }
    else if (evt.target instanceof Choice)
    {
      String labl = (String)arg;
      if ( labl.compareTo("Ellipse") == 0 )
        areageom = 2;
      else  // default Rectangle
        areageom = 1;
      return true;
    }
    else
      return false;
  }

  public void update(Graphics screen)
  {
     paint(screen);
  }


  public void paint(Graphics screen)
  {
    int i;

    // clear screen

    if (areageom == 1) // Rectangle
    {
      offscreen.setColor(Color.white);
      offscreen.fillRect(0,0,canvas_width,canvas_height);
    }
    else if (areageom == 2) // Ellipse
    {
      offscreen.setColor(Color.gray);
      offscreen.fillRect(0,0,canvas_width,canvas_height);
      offscreen.setColor(Color.white);
      offscreen.fillOval(0,0,canvas_width,canvas_height);
    }

    // draw swarm to background buffer

    //    offscreen.setColor(Color.red);

    for (i=0; i<N; i++)
    {
      offscreen.setColor( colortab[colorindex[i]] );
      offscreen.fillOval( (int)(canvas_width*xp[i])-elemSize,
                          (int)(canvas_height*yp[i])-elemSize,
			  2*elemSize+1, 2*elemSize+1);
    }

    // display background buffer

    Graphics gr = canvas.getGraphics();
    gr.drawImage(offscreenImg, 0, 0, this );
  }
  
  


}