/*
 * Paul Garrett, March 1999
 *
 * Zoom in/out on Mandelbrot set
 *
 * Thread it so that viewer can see the picture paint itself
 */ 

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

public class Mandelbrot extends Applet {

	 int size = 64; // power-of-2
	 int limit = 150; // number of iterations to count as "escape"

	 final int numberColors = 10;
	 final Color[] colors = { Color.gray, Color.gray, Color.blue, Color.red,
									  Color.yellow, Color.magenta, Color.pink, Color.green,
									  Color.orange, Color.black};

	 boolean queryComputed = false;

	 int[][] colorIndices;

	 double xCenter, yCenter, radius;

	 TextField limitTF;
	 TextField sizeTF;
	 TextField xCenterTF;
	 TextField yCenterTF;
	 TextField radiusTF;

	 public void init() {
		  xCenter = -0.7;
		  yCenter = 0.0;
		  radius = 1.4;

		  setLayout(null);

		  xCenterTF = new TextField(10);
		  xCenterTF.resize(new Dimension(100,30));
		  add( xCenterTF );
		  xCenterTF.move(350, 30);
		  xCenterTF.setText(""+xCenter);

		  yCenterTF = new TextField(10);
		  yCenterTF.resize(new Dimension(100,30));
		  add( yCenterTF );
		  yCenterTF.move(350, 55);
		  yCenterTF.setText(""+yCenter);

		  radiusTF = new TextField(10);
		  radiusTF.resize(new Dimension(100,30));
		  add( radiusTF );
		  radiusTF.move(350, 80);
		  radiusTF.setText(""+radius);

		  limitTF = new TextField(10);
		  limitTF.resize(new Dimension(100,30));
		  add( limitTF );
		  limitTF.move(350, 200);
		  limitTF.setText(""+ limit);

		  sizeTF = new TextField(10);
		  sizeTF.resize(new Dimension(100,30));
		  add( sizeTF );
		  sizeTF.move(350, 230);
		  sizeTF.setText("" + size);
	 }

	 final double[] f(double[] z, double[] c) {
		  double x = z[0];
		  double y = z[1];
		  double[] out = { x*x - y*y + c[0], 2*x*y + c[1]}; 
		  return out;
	 }

	 final double normSq(double[] z) {
		  return z[0]*z[0]+z[1]*z[1];
	 }

	 final double index(double cx, double cy) {
		  double[] c = {cx,cy};
		  int ix = 0;
		  double[] z = {0.0,0.0};
		  while (normSq(z) <= 4 && ix < limit) { //__EDIT__
				z = f(z,c);
				ix++;
		  }
		  return Math.sqrt(((double) ix)/((double) limit));
	 }

	 void initColorIndices(double xCenter, double yCenter, double radius) {
		  for(int i=0; i<size; i++) {
				for (int j=0; j<size; j++) {
					 colorIndices[i][j] = 0; // all white, initially
				}
		  }
	 }

	 public void paint(Graphics g) {
		  g.drawString("Center x = ", 270, 50);
		  g.drawString("Center y = ", 270, 75);
		  g.drawString("Radius = ", 270, 100);
		  g.drawString("Click to recenter at cursor", 260, 145);
		  g.drawString("and magnify by factor of 1.4", 260, 160);
		  g.drawString("Resolution 32, 64, 128, or 256", 260, 185);
		  g.drawString("limit", 260, 220);
		  g.drawString("res", 260, 250);
		  if (queryComputed == false) {
				g.setColor(Color.red);
				g.drawString("...computing...", 280, 25);
				double inc = 2*radius/size;
				double nwx = xCenter - radius;
				double nwy = yCenter - radius;
				double x,y;
				int boxSize = 256;
				int bx = size;
				colorIndices = new int[size][size];
				for(int t=1; t<=size; t *= 2) {
					 for(int i=0; i<t; i++) {
						  x = nwx + i*bx*inc;
						  for (int j=0; j<t; j++) {
								if (j<4 || i<4 || j%2==1 || i%2==1) {
									 y = nwy + j*bx*inc;
									 colorIndices[i*bx][j*bx] = 
										  (int) Math.round(9*index(x,y));
									 g.setColor( colors[ colorIndices[i*bx][j*bx] ] );
									 g.fillRect(i*boxSize, j*boxSize, boxSize, boxSize);
								}
						  }
					 }
					 bx /= 2;
					 boxSize /= 2;
				}
				g.setColor(Color.lightGray);
				g.fillRect(280,0,100,35);
				queryComputed = true;
		  }
		  else { // queryComputed == true
				int boxSize = 256;
				int bx = size;
				for(int t=1; t<=size; t *= 2) {
					 for(int i=0; i<t; i++) {
						  for (int j=0; j<t; j++) {
								g.setColor( colors[ colorIndices[i*bx][j*bx] ] );
								g.fillRect(i*boxSize, j*boxSize, boxSize, boxSize);
						  }
					 }
					 bx /= 2;
					 boxSize /= 2;
				}
		  }
	 }

	 int powerRound( int x ) {
		  return (int) Math.round(Math.exp( Math.log(2) * Math.floor(Math.log(x)/Math.log(2)) ));
	 }

	 double smooth(double x) {
		  return Math.round(x * 100000)/100000.0;
	 }

	 void reinit() {
		  queryComputed = false;
		  xCenter = smooth(Double.valueOf(xCenterTF.getText()).doubleValue());
		  yCenter = -smooth(Double.valueOf(yCenterTF.getText()).doubleValue());
		  radius = smooth(Double.valueOf(radiusTF.getText()).doubleValue());
		  xCenterTF.setText(""+xCenter);

		  double y = -yCenter;
		  yCenterTF.setText(""+y);
		  radiusTF.setText(""+radius);
		  limit = Integer.parseInt(limitTF.getText());
		  size = Integer.parseInt(sizeTF.getText());
		  size = powerRound(size);
		  size = Math.min(size, 256);
		  size = Math.max(size, 32);
		  sizeTF.setText(""+size);
		  colorIndices = new int[size][size];
	 }

	 public boolean handleEvent(Event e) {
		  if (e.target instanceof TextField && e.id == Event.ACTION_EVENT) {
				reinit();
				repaint();
				return true;
		  }
		  else if (e.id == Event.MOUSE_DOWN && e.x < 256 && e.y < 256
					  && e.x > 0 && e.y > 0) {
				xCenter = smooth(xCenter + radius*((double) (e.x-128))/128.0);
				yCenter = smooth(yCenter + radius*((double) (e.y-128))/128.0);
				xCenterTF.setText(""+xCenter);
				double y = -yCenter;
				yCenterTF.setText(""+y);
				radius = smooth(radius/1.4);
				radiusTF.setText(""+radius);

				reinit();
				repaint();
				return true;
		  }
		  else {
				return false;
		  }
	 }

}
/************************************************************/
// end of class "Mandelbrot"
/************************************************************/