import java.awt.*;
import java.awt.image.*;
import java.awt.event.*;
import java.applet.*;

public class GrayScott extends Applet 
implements Runnable,MouseListener,MouseMotionListener {
	
	int width,height;
	double[][] U,V,newU,newV;
	int[] pix;
	MemoryImageSource mis;
	Image image;
	Thread thread;
	
	double Du = 0.04;
	double Dv = 0.02;
	double F = 0.02;
	double k = 0.06;
	double u0 = 0.25;
	double v0 = 0.33;
	double r = 1;
	int T = 5;
	int x0,y0;
	
    public void init() {
		width = getSize().width;
		height = getSize().height;
		U = new double[height][width];
		V = new double[height][width];
		newU = new double[height][width];
		newV = new double[height][width];
		pix = new int[width*height];
		mis = new MemoryImageSource(width,height,pix,0,width);
		mis.setAnimated(true);
		image = getToolkit().createImage(mis);
		addMouseListener(this);
		addMouseMotionListener(this);
		for (int y=0;y<height;y++)
			for (int x=0;x<width;x++) {
				U[y][x] = 1;
				V[y][x] = 0;
			}
		try {
			Du = Double.valueOf(getParameter("Du")).doubleValue();
		} catch (RuntimeException e) {
		}
		try {
			Dv = Double.valueOf(getParameter("Dv")).doubleValue();
		} catch (RuntimeException e) {
		}
		try {
			F = Double.valueOf(getParameter("F")).doubleValue();
		} catch (RuntimeException e) {
		}
		try {
			k = Double.valueOf(getParameter("k")).doubleValue();
		} catch (RuntimeException e) {
		}
		try {
			T = Integer.parseInt(getParameter("T"));
		} catch (RuntimeException e) {
		}
		try {
			r = Double.valueOf(getParameter("r")).doubleValue();
		} catch (RuntimeException e) {
		}
		try {
			u0 = Double.valueOf(getParameter("u0")).doubleValue();
		} catch (RuntimeException e) {
		}
		try {
			v0 = Double.valueOf(getParameter("v0")).doubleValue();
		} catch (RuntimeException e) {
		}
    }
	
	public void start() {
		thread = new Thread(this);
		thread.setDaemon(true);
		thread.start();
	}
	
	public void stop() {
		thread.interrupt();
	}
	
	public void run() {
		while (!Thread.interrupted()) {
			for (int t=0;t<T;t++) synchronized (this) {
				for (int y=0;y<height;y++)
					for (int x=0;x<width;x++) {
						newU[y][x] = U[y][x]
							+Du*(
								+U[y][x>0?x-1:width-1]
								+U[y][x<width-1?x+1:0]
								+U[y>0?y-1:height-1][x]
								+U[y<height-1?y+1:0][x]
								-4*U[y][x])
							-U[y][x]*V[y][x]*V[y][x]
							+F*(1-U[y][x]);
						newV[y][x] = V[y][x]
							+Dv*(
								+V[y][x>0?x-1:width-1]
								+V[y][x<width-1?x+1:0]
								+V[y>0?y-1:height-1][x]
								+V[y<height-1?y+1:0][x]
								-4*V[y][x])
							+U[y][x]*V[y][x]*V[y][x]
							-(F+k)*V[y][x];
					}
				double[][] tempU = U;
				double[][] tempV = V;
				U = newU;
				V = newV;
				newU = tempU;
				newV = tempV;
			}
			synchronized (this) {
				for (int i=0,y=0;y<height;y++)
					for (int x=0;x<width;x++,i++) {
						pix[i] = 
							255<<24|
							(int)Math.max(0,Math.min(500*(1-U[y][x]),255))<<16|
							(int)Math.max(0,Math.min(1000*V[y][x],255))<<8|
							0;
					}
				mis.newPixels();
				repaint();
			}
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				break;
			}
		}
	}
	
	private synchronized void drawLine(int x0,int y0,int x1,int y1) {
		double nx = x1-x0;
		double ny = y1-y0;
		double n2 = nx*nx+ny*ny;
		double r2 = r*r;
		for (int y=0;y<height;y++)
			for (int x=0;x<width;x++) {
				double dx = x-x0;
				double dy = y-y0;
				double d2 = dx*dx+dy*dy;
				double dn = dx*nx+dy*ny;
				if (dn<0) {
				} else if (dn<n2) {
					d2 -= dn*dn/n2;
				} else {
					d2 += n2-2*dn;
				}
				if (d2<r2) {
					U[y][x] = u0;
					V[y][x] = v0;
				}
			}
	}
	
	public void mouseEntered(MouseEvent e) {
	}
	
	public void mouseExited(MouseEvent e) {
	}
	
	public void mousePressed(MouseEvent e) {
		x0 = e.getX();
		y0 = e.getY();
		drawLine(x0,y0,x0,y0);
	}
	
	public void mouseReleased(MouseEvent e) {
	}
	
	public void mouseClicked(MouseEvent e) {
	}
	
	public void mouseMoved(MouseEvent e) {
	}
	
	public void mouseDragged(MouseEvent e) {
		int x1 = e.getX();
		int y1 = e.getY();
		drawLine(x0,y0,x1,y1);
		x0 = x1;
		y0 = y1;
	}
	
    public void update(Graphics g) {
		paint(g);
	}
	
    public synchronized void paint(Graphics g) {
		g.drawImage(image,0,0,this);
    }
}