/*
 * Copyright (c) 2002 Aravind Krishnaswamy. All  Rights Reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * -Redistributions of source code must retain the above copyright
 *  notice, this list of conditions and the following disclaimer.
 * 
 * -Redistribution in binary form must reproduct the above copyright
 *  notice, this list of conditions and the following disclaimer in
 *  the documentation and/or other materials provided with the distribution.
 * 
 * 
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
 * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT
 * BE LIABLE FOR ANY DAMAGES OR LIABILITIES SUFFERED BY LICENSEE AS A RESULT
 * OF OR RELATING TO USE, MODIFICATION OR DISTRIBUTION OF THE SOFTWARE OR ITS
 * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
 * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
 * INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY
 * OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE SOFTWARE, EVEN
 * IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 * 
 * You acknowledge that Software is not designed, licensed or intended for
 * use in the design, construction, operation or maintenance of any nuclear
 * facility.
 */

/*
 * @(#)Fractal.java	1.00 08/30/2002
 */

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

public class MandelbrotFractalApplet extends Applet 
{
	MandelbrotFractalDrawPanel panel;
	MandelbrotFractalControls controls;

	public void init()
	{
		setLayout( new BorderLayout() );
		panel = new MandelbrotFractalDrawPanel( 256, 256 );
		controls = new MandelbrotFractalControls( panel );
		add( "Center", panel );
		add( "South", controls );
	}

	public void destroy()
	{
		remove( panel );
	}

	public static void main( String args[] )
	{
		Frame f = new Frame("Mandelbrot Fractal test");
		MandelbrotFractalApplet fractal = new MandelbrotFractalApplet( );
		fractal.init();
		fractal.start();
		f.add( "Center", fractal );
		
		f.setSize( 700, 300 );
		f.show();
	}

	public String getAppletInfo() {
		return "Mandelbrot fractal viewer by Aravind Krishnaswamy";
    }	
}

class MandelbrotFractalDrawPanel extends Panel
{
	public MandelbrotFractal fractal = new MandelbrotFractal();
	private BufferedImage	output;

	private double lastX = 0;
	private double lastY = 0;


	public MandelbrotFractalDrawPanel( int width, int height )
	{
		output = new BufferedImage( width, height, BufferedImage.TYPE_INT_ARGB );
		GenerateFractalImage( );
	}

	public void paint( Graphics g )
	{
		g.clearRect( 0, 0, this.getSize().width, this.getSize().height );
		g.drawImage( output, 0, 0, this );
	}

	public void GenerateFractalImage( )
	{
		for( int y=0; y<output.getHeight(); y++ )
		{
			double dy = (double)y / (double)output.getHeight();
			for( int x=0; x<output.getWidth(); x++ )
			{
				double dx = (double)x / (double)output.getWidth();
				PEL p = fractal.GetColor( dx, dy );
				int rgb = 0xFF000000 | ((int)(p.r*255.0) << 16) | ((int)(p.g*255.0) << 8) | (int)(p.b*255.0);
				output.setRGB( x, y, rgb );
			}
		}
	}
}

class MandelbrotFractalControls extends Panel implements ActionListener
{
	private MandelbrotFractalDrawPanel target;
	private TextField	startX;
	private TextField	endX;
	private TextField	startY;
	private TextField	endY;
	private TextField	exponent;
	private Button button;

	public MandelbrotFractalControls( MandelbrotFractalDrawPanel target )
	{
		this.target = target;
		setLayout( new FlowLayout() );

		// Add the buttons and stuff here
		add( new Label( "X start") );
		add( startX = new TextField( Double.toString(target.fractal.lower_x), 4) );

		add( new Label( "X end") );
		add( endX = new TextField( Double.toString(target.fractal.upper_x), 4) );

		add( new Label( "Y start") );
		add( startY = new TextField( Double.toString(target.fractal.lower_y), 4) );

		add( new Label( "Y end") );
		add( endY = new TextField( Double.toString(target.fractal.upper_y), 4) );

		add( new Label( "Exponent") );
		add( exponent = new TextField( Double.toString(target.fractal.exp), 4) );
		
		add( button = new Button( "Render Fractal" ));
		button.addActionListener( this );
	}

	/**
	 * Retreives the values from the text boxes
	 */
	public void getParams( )
	{
		try {
			target.fractal.lower_x = Double.parseDouble( startX.getText() );
		} catch( NumberFormatException e ) {
			target.fractal.lower_x = -1.0;
		}
		
		try {
			target.fractal.upper_x = Double.parseDouble( endX.getText() );
		} catch( NumberFormatException e ) {
			target.fractal.upper_x = -1.0;
		}

		try {
			target.fractal.lower_y = Double.parseDouble( startY.getText() );
		} catch( NumberFormatException e ) {
			target.fractal.lower_y = -1.0;
		}
		
		try {
			target.fractal.upper_y = Double.parseDouble( endY.getText() );
		} catch( NumberFormatException e ) {
			target.fractal.upper_y = -1.0;
		}

		try {
			target.fractal.exp = Double.parseDouble( exponent.getText() );
		} catch( NumberFormatException e ) {
			target.fractal.exp = -1.0;
		}
	}

	/**
	 * Called when the user clicks the button
	 **/
	public void actionPerformed( ActionEvent e )
	{
		if( e.getSource() == button )
		{
			getParams();
			target.GenerateFractalImage();
			target.repaint();
		}
	}
}

class PEL
{
	public double r=0, g=0, b=0;

	public PEL( )
	{
	}
	
	public PEL( double r, double g, double b )
	{
		this.r = r;
		this.g = g;
		this.b = b;
	}
}

class MandelbrotFractal
{
	private PEL		colorA = new PEL( 1.0, 0.0, 0.0 );
	private PEL		colorB = new PEL( 0.0, 0.0, 1.0 );

	public double	lower_x = -1.75;
	public double	upper_x = 0.75;
	public double	lower_y = -1.25;
	public double	upper_y = 1.25;
	
	public double	exp = 12.0;

	public MandelbrotFractal( )
	{
	}

	public MandelbrotFractal( PEL a, PEL b, double lx, double ux, double ly, double uy, double ex )
	{
		colorA = a;
		colorB = b;
		lower_x = lx;
		upper_x = ux;
		lower_y = ly;
		upper_y = uy;
		exp = ex;
	}

	private static int count_mandelbrot_steps( double xn, double yn, double x, double y, int count_so_far )
	{
		double xnsq = xn * xn;
		double ynsq = yn * yn;

		double mag = xnsq + ynsq;

		if( count_so_far >= 256 )
			return count_so_far;

		if( mag > 4 )
			return count_so_far;

		return count_mandelbrot_steps( xnsq - ynsq + x, 2 * xn * yn + y, x, y, count_so_far + 1 );
	}

	public PEL GetColor( double x, double y )
	{
		double	fracx = x*(upper_x - lower_x) + lower_x;
		double	fracy = y*(upper_y - lower_y) + lower_y;

		int count = count_mandelbrot_steps( fracx, fracy, fracx, fracy, 0 );
		double	d = 1.0 - (count / 256.0);

		if( (exp > 1.0) || (exp < 1.0) )
			d = Math.pow( d, exp );

		double OMd = 1.0 - d;

		// Interpolate
		PEL ret = new PEL();
		ret.r = colorA.r * OMd + colorB.r * d;
		ret.g = colorA.g * OMd + colorB.g * d;
		ret.b = colorA.b * OMd + colorB.b * d;

		return ret;
	}
}