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


public class inf
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;

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

  int sleeptime = 25; // Milliseconds

  // tau = 1 assumed
  double speed = 1.01;  // I
  double scale = 1.;
  double noise = 0.3;
  double eps   = .000;

  int elemSize = 25;

  int width, height;
  int canvas_width;
  int canvas_height;


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


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

    bgColor = new Color( .85f, .85f, 0.f );

    colortab[0] = new Color(1.f, 0.f, 0.f );

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


    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") );

    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("input", 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);

    // initialize to random values

    for (i=0; i<Nmax*Nmax; i++)
    {
      phi[i] = r.nextDouble();
      out[i] = 0.;
    }

  }


  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 recrurrent inputs

      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+= out[j];  // weighting function here !!!!!!!!!!!!!!!!
	  }
	rhs[i] = h1;
      }

      // leaky integration

      for (i=0; i<NN; i++)
        phi[i] += .1*(-phi[i] + speed
	     + eps*rhs[i] + noise*(r.nextDouble()-.5));

      
      // compute new colors and fire if phi > 1

      for (i=0; i<NN; i++)
      {
        if (phi[i]>1.)
	{
	  out[i] = 1.;
	  phi[i] = 0.;
	}
        else
	  out[i] = 0.;
      }

      // we don't want delays, so redistribute spikes and fire again

      
      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+= out[j];  // weighting function here !!!!!!!!!!!!!!!!
	  }
	rhs[i] = h1;
      }

      for (i=0; i<NN; i++)
        phi[i] += .1*eps*rhs[i];

      for (i=0; i<NN; i++)
      {
        if (phi[i]>1.)
	{
	  out[i] = 1.;
	  phi[i] = 0.;
	}
        else
	  out[i] = 0.;
      }

      // compute new colors
      for (i=0; i<NN; i++)
      {
        colorindex[i] = (int)(phi[i]*(numcolors-1));
      }

      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;

      // initialize to random values

      for (i=0; i<NN; i++)
      {
        phi[i] = r.nextDouble();
	out[i] = 0.;
      }
      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.setColor( bgColor );
    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 );
  }
  
  


}