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


public class phasor
extends java.applet.Applet
implements Runnable
{

  int Nmax = 100;
  int numcolors = 128;
  Color colortab[] = new Color[numcolors];
  int colorindex[] = new int[Nmax*Nmax];

  int sleeptime = 25; // Milliseconds


  double speed = .1;
  double scale = 1.;
  double noise = 0.;
  double eps   = .1;  // .01 .001

  int elemSize = 5;

  int width, height;
  int canvas_width;
  int canvas_height;


  int N = 51;
  int NN=N*N;
  double phi[] = new double[Nmax*Nmax];
  double rhs[] = new double[Nmax*Nmax];


  Thread runner;
  Image offscreenImg;
  Graphics offscreen;
  Canvas canvas = new Canvas();
  Button initB = new Button("init");
  Label Nlabel = new Label( "N", Label.RIGHT ),
        esizelabel = new Label( "size", Label.RIGHT ),
	speedlabel = new Label("omega", Label.RIGHT),
        scalelabel = new Label("scale", Label.RIGHT),
	noiselabel = new Label("noise", Label.RIGHT),
	epslabel  = new Label("coupling", Label.RIGHT);
  TextField Ntf = new TextField( Integer.toString( N ) ),
            esizetf = new TextField( Integer.toString( elemSize ) ),
	    speedtf = new TextField( Double.toString( speed )),
	    scaletf = new TextField( Double.toString( scale )),
	    noisetf = new TextField( Double.toString( noise )),
	    epstf  = new TextField( Double.toString( eps ) );
  FlowLayout lm = new FlowLayout(FlowLayout.LEFT);
//   GridLayout lm = new GridLayout(10, 1);

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

    setLayout(lm );

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

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

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

    canvas.setBackground(Color.white);
    canvas.resize( canvas_width, canvas_height );

    add(canvas);

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

    add(initB);

    add(Nlabel);
    add(Ntf);

    add(esizelabel);
    add(esizetf);

    add(speedlabel);
    add(speedtf);

    add(scalelabel);
    add(scaletf);

    add(noiselabel);
    add(noisetf);

    add(epslabel);
    add(epstf);

    // initialize to random phases

    for (i=0; i<NN; i++)
      phi[i] = 2*Math.PI*r.nextDouble();

  }


  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,k,l;
    Random r = new Random();
    double h1;
    int xx, yy, sc;

    Thread thisThread = Thread.currentThread();
    while (runner == thisThread)
    {
      sc = (int)(scale);

      // compute new phases

      for (i=0; i<NN; i++)
      {
        xx = i%N;
	yy = i/N;
        h1 = 0.;
        for (k=-sc; k<=sc; k++)
	  for (l=-sc; l<=sc; l++)
          {
	    j = ((xx+k+N)%N) + ((yy+l+N)%N)*N;
            h1+= Math.sin(phi[j]-phi[i]);
	  }
	rhs[i] = h1;
      }

      for (i=0; i<NN; i++)
      {

        phi[i] += speed + eps*rhs[i] + noise*(r.nextDouble()-.5);

        while (phi[i] >= 2*Math.PI)
	  phi[i] -= 2*Math.PI;
        while (phi[i] < 0)
	  phi[i] += 2*Math.PI;
      }
      
      // compute new colors

      for (i=0; i<NN; i++) 
        colorindex[i] = (int)(phi[i]*(numcolors-1)/(2*Math.PI));

      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 >=3. && newValue < Nmax)
	  N = (int)newValue;
	  NN = N*N;
      }


      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 <= 100)
	  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 < (N-1))
	  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<NN; i++)
        phi[i] = 2*Math.PI*r.nextDouble();
      return true;
    }
    else
      return false;
  }

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


  public void paint(Graphics screen)
  {
    int i;

    // clear screen

    offscreen.setColor(Color.white);
    offscreen.fillRect(0,0,canvas_width,canvas_height);


    // draw to background buffer

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


    // display background buffer

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

}