/**
 * CircularFilterApplet.java
 * Copyright (c) 1998 Yoon Kyung Koo. All rights reserved.
 *
 * First release date 1998/06/07
 *
 * @version 1.0 1998/06/07
 * @author <A HREF="mailto:yoonforh@moon.daewoo.co.kr">Yoon Kyung Koo</A>
 */

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

/**
 * CircularFilterApplet class
 * This applet shows an image filter example
 */

public class CircularFilterApplet
	extends java.applet.Applet implements Runnable
{
	private Image image=null;
	private int nodes=0;
	private int amplitude=0;
	private int frameNo=0;
	private int currentFrame=0;
	private int animInterval=0;
	private Image filtered[]=null;
	private boolean isLoaded=false;
	private boolean isFiltered=false;
	private MediaTracker tracker=null;
	private Thread animThread=null;

	public void init() {
		image = getImage(getCodeBase(), getParameter("image"));
		String nodes = getParameter("node");
		if (nodes==null)
			this.nodes=5;
		else
			this.nodes=Integer.valueOf(nodes).intValue();
		String amplitude = getParameter("amplitude");
		if (amplitude==null)
			this.amplitude=15;
		else
			this.amplitude=Integer.valueOf(amplitude).intValue();
		String frameNo = getParameter("frame");
		if (frameNo==null)
			this.frameNo=5;
		else
			this.frameNo=Integer.valueOf(frameNo).intValue();
		String animInterval = getParameter("delay");
		if (animInterval==null)
			this.animInterval=100;
		else
			this.animInterval=Integer.valueOf(animInterval).intValue();
		tracker=new MediaTracker(this);
		tracker.addImage(image, 0);
	}

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

	public void run() {
		Thread me=Thread.currentThread();
		try {
			tracker.waitForID(0);
			int width=image.getWidth(this);
			int height=image.getHeight(this);
			Point center=new Point(width/2, height/2);
			double radius=Math.sqrt(width*width/4.0+height*height/4.0);
			isLoaded=true;
			repaint();
			ImageProducer prod=image.getSource();
			Image images[]=new Image[frameNo];
			filtered=images;
			for (int i=0; i<frameNo; i++) {
				filtered[i]=createImage(new FilteredImageSource(prod, 
					new CircularImageFilter(center, radius, nodes,
						amplitude, i, frameNo)));
				tracker.addImage(filtered[i], 1);
			}
			tracker.waitForID(1);
			currentFrame=0;
			repaint();
			isFiltered=true;
		} catch (InterruptedException ie) {}

		while (animThread==me) {
			repaint();
			try {
			Thread.currentThread().sleep(animInterval);
			} catch (InterruptedException ie) {}
			currentFrame=++currentFrame%frameNo;
			image=filtered[currentFrame];
		}
	}

	public void stop() {
		synchronized (this) {
			animThread=null;
		}
	}

	public void paint(Graphics g) {
		if (image==null) {
			Font font = new Font("Helvetica", Font.BOLD, 14);
			g.setFont(font);
			g.drawString("You should specify image parameter", 10, 10);
			return;
		}
		if (!isLoaded) {
			g.drawString("loading images...", 10, 10);
			return;
		}
		g.drawImage(image, 0, 0, this);
		/*
		if (isFiltered) {
			for (int i=0; i<frameNo; i++)
				g.drawImage(filtered[i], image.getWidth(this)*i, image.getHeight(this), this);
		}
		*/
		if (!isFiltered) {
			Font font = new Font("Helvetica", Font.BOLD, 14);
			g.setFont(font);
			g.setColor(Color.gray);
			g.drawString("Filtering images...", 1, image.getHeight(this)/2);
		}
	}

	public void update(Graphics g) {
		if (image==null)
			return;
		paint(g);
	}

}

/**
 * CircularImageFilter class
 * This class provides brightening or darkening filter
 */

class CircularImageFilter extends RGBImageFilter {
	Point center=null;
	double radius=0.0;
	int nodes=0;
	int phase=0;
	int frames=0;
	int amplitude=0;

	CircularImageFilter (
		Point center, double radius, int nodes,
		int amplitude, int phase, int frames) {
		this.center=center;
		this.radius=radius;
		this.nodes=nodes;
		this.amplitude=amplitude;
		this.phase=phase;
		this.frames=frames;
	}

	private int getFilterDepth(int x, int y) {
		double distance=
			Math.sqrt((double) (center.x-x)*(center.x-x)+
				(double) (center.y-y)*(center.y-y));

		/* a simple sine curve equation about variable distance */
		return (int) ( amplitude
				*Math.sin(2.0*Math.PI*nodes/radius*distance
					+ (double)phase*2.0*Math.PI/(double)frames ));
	}

	public int filterRGB(int x, int y, int rgb) {
		int percent=getFilterDepth(x, y);
		int r = (rgb >> 16) & 0xff;
		int g = (rgb >> 8) & 0xff;
		int b = (rgb >> 0) & 0xff;
		if (percent < 0) { // darken
			r = (0xff - ((0xff - r) * (100 + percent) / 100));
			g = (0xff - ((0xff - g) * (100 + percent) / 100));
			b = (0xff - ((0xff - b) * (100 + percent) / 100));
		}
		else { // brighten
			r = r * (100 - percent) / 100;
			g = g * (100 - percent) / 100;
			b = b * (100 - percent) / 100;
		}
		return (rgb & 0xff000000) | (r << 16) | (g << 8) | (b << 0);
	}
}