// Copyright (c) 1996 Jared Smith-Mickelson http://web.mit.edu/jaredsm/www/

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

public class Wave extends Applet implements Runnable {
	Image			img[], offscreenI;
	IndexColorModel	palette[];
	MediaTracker	tracker;
	Thread			runner;
	boolean			loading;
	String			status;
	Graphics		offscreenG, realG;
	int				width, height, frame, color1, color2;
	int				frames, colors, neg, pos, speed, density;
	byte			pix[];
	double			fraction;
	Color			barColor;

	public void init() {
		System.err.println("Wave, by Jared Smith-Mickelson - " +
			"http://web.mit.edu/jaredsm/www/");
		loading = true;
		realG = getGraphics();
		width = bounds().width;
		height = bounds().height;
		// create offscreen images for animation buffering
		offscreenI = createImage(width, height);
		offscreenG = offscreenI.getGraphics();
		barColor = new Color(0xff3900);
		// parse the HTML parameters
		try { color1 = Integer.parseInt(getParameter("color1"), 16); }
		catch (NumberFormatException e) { color1 = 0x000000;
			System.out.println("Couldn't parse color1.");	}
		try { color2 = Integer.parseInt(getParameter("color2"), 16); }
		catch (NumberFormatException e) { color2 = 0xff5000;
			System.out.println("Couldn't parse color2."); }
		try { frames = Integer.parseInt(getParameter("frames")); }
		catch (NumberFormatException e) { frames = 32;
			System.out.println("Couldn't parse frames."); }
		try { colors = Integer.parseInt(getParameter("colors")); }
		catch (NumberFormatException e) { colors = 256;
			System.out.println("Couldn't parse colors."); }
		try { neg = Integer.parseInt(getParameter("neg")); }
		catch (NumberFormatException e) { neg = 3;
			System.out.println("Couldn't parse neg."); }
		try { pos = Integer.parseInt(getParameter("pos")); }
		catch (NumberFormatException e) { pos = 3;
			System.out.println("Couldn't parse pos."); }
		try { speed = Integer.parseInt(getParameter("speed")); }
		catch (NumberFormatException e) { speed = 20;
			System.out.println("Couldn't parse speed."); }
		try { density = Integer.parseInt(getParameter("density")); }
		catch (NumberFormatException e) { density = 20;
			System.out.println("Couldn't parse density."); }
	}

	public void run() {
		// initialize all the positive and negative points
		double posX[] = new double[neg];
		double posY[] = new double[neg];
		double negX[] = new double[pos];
		double negY[] = new double[pos];
		for(int i = 0; i < neg; i++) {
			posX[i] = width * Math.random();
			posY[i] = height * Math.random();
		}
		for(int i = 0; i < pos; i++) {
			negX[i] = width * Math.random();
			negY[i] = height * Math.random();
		}
		// build the original image
		pix = new byte[width * height];
		int index = 0;
		double potential;
		for(int y = 0; y < height; y++) {
			// update the status every 10 lines
			if(y % 10 == 0) {
				fraction = (double)(y) / height / 2;
				status("Building original image...");
			}
			for(int x = 0; x < width; x++) {
				potential = 0;
				// the following two functions are arbitrary.  different
				// functions result in totaly different swirls and whirls
				// of color.  get creative!  go crazy!
				for(int i = 0; i < neg; i++)
					potential+= Math.log((y - posY[i]) * (y - posY[i]) +
									 (x - posX[i]) * (x - posX[i]));
				for(int i = 0; i < pos; i++)
					potential-= Math.log((y - negY[i]) * (y - negY[i]) +
									 (x - negX[i]) * (x - negX[i]));
				// asign potentials to real color indices
				potential = ((potential * density) % colors + colors) % colors;
				pix[index++] = (byte)(potential);
			}
		}
		// build palettes based on color1 and color2
		palette = new IndexColorModel[frames];
		byte baseR[] = new byte[colors];
		byte baseG[] = new byte[colors];
		byte baseB[] = new byte[colors];
		int r1 = (color1 & 0xff0000) >> 16;
		int r2 = (color2 & 0xff0000) >> 16;
		int g1 = (color1 & 0x00ff00) >> 8;
		int g2 = (color2 & 0x00ff00) >> 8;
		int b1 = color1 & 0x0000ff;
		int b2 = color2 & 0x0000ff;
		int mid = colors / 2;
		for(int i = 0; i < mid; i++) {
			baseR[i] = (byte)(r1 + i * (r2 - r1) / mid );
			baseG[i] = (byte)(g1 + i * (g2 - g1) / mid );
			baseB[i] = (byte)(b1 + i * (b2 - b1) / mid );
		}
		for(int i = mid; i < colors; i++) {
			baseR[i] = (byte)(r2 - ((i - mid) * (r2 - r1) / (colors - mid)));
			baseG[i] = (byte)(g2 - ((i - mid) * (g2 - g1) / (colors - mid)));
			baseB[i] = (byte)(b2 - ((i - mid) * (b2 - b1) / (colors - mid)));
		}
		byte shadeR[] = new byte[colors];
		byte shadeG[] = new byte[colors];
		byte shadeB[] = new byte[colors];
		for(int mod = 0; mod < frames; mod++) {
			for(int i = 0; i < colors; i++) {
				shadeR[i] = baseR[(i + mod * colors / frames) % colors];	
				shadeG[i] = baseG[(i + mod * colors / frames) % colors];	
				shadeB[i] = baseB[(i + mod * colors / frames) % colors];	
			}
			palette[mod] = new IndexColorModel(8, colors,
													shadeR, shadeG, shadeB);
		}
		// create images
		img = new Image[frames];
		tracker = new MediaTracker(this);
		for(int i = 0; i < frames; i++) {
			img[i] = createImage(new MemoryImageSource(width, height,
												palette[i], pix, 0, width));
			tracker.addImage(img[i], i);
		}
		for(int i = 0; i < frames; i++) {
			fraction = .5 + (double)(i) / frames / 2;
			status("Creating animation images...");
			try { tracker.waitForID(i); } catch (InterruptedException e) { ; }
		}
		loading = false;
		frame = 0;
		// animate forever
		while(true) {
			offscreenG.drawImage(img[frame], 0, 0, this);
			update(realG);
			frame = (frame + 1) % frames;
			wait(speed);
		}
	}

	void wait(int time) {
		try { runner.sleep(time); } catch (InterruptedException e) { ; }
	}

	void status(String text) {
		status = text;
		paint(offscreenG);
		update(realG);
		wait(100);
	}
	
	public void start() {
		if(runner == null) {
			runner = new Thread(this);
			runner.start();
		}
	}

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

	public void paint(Graphics g) {
		if(g == null)
			return;
		if(loading) {
			// draw a nifty status bar
			int y = height / 2;
			g.setColor(Color.black);
			g.fillRect(0, 0, width, height);
			g.setColor(Color.white);
			g.drawString(status, 10, y - 4);
			g.drawRect(10, y, width - 20, 12);
			g.setColor(barColor);
			g.fillRect(11, y + 2, (int)(fraction * (width - 22)), 9);
		} else
			g.drawImage(img[frame], 0, 0, this);
	}

	public void update(Graphics g) {
		g.drawImage(offscreenI, 0, 0, this);
	}
}