//http://timestocome.com
//Linda MacPhee-Cobb


//Mandelbrot is a fractal
//The equation for the Mandlebrot is Z <- Z^2 + C
//Z is the complex number x +yi where x and y are usually set to zero to start
//C is the points in the plant you are mapping x + yi
//

//Clicking your mouse in the window re-centers the view on your click
//Hit the + key to double the size
//Hit the - key to half the size


import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class Mandelbrot extends Frame implements Runnable, WindowListener, MouseListener, KeyListener
{

	//  Globals
	int MAX = 500;							//size of window in pixels
	double lowX, highX, lowY, highY;		//range for Mandelbrot
	double x0, y0;							//center of Mandelbrot function
	int max_iterations = 1000;
	int iteration_array[] = new int[max_iterations];	// how many iterations for each number do we go through loop?
	

	
	public static void main ( String[] args )
	{
		new Mandelbrot();
	}
	
	
	//set up window and initial values
	public Mandelbrot()
	{
		//window set up
		super ( " Window Display " );
		setBounds ( 0, 0, MAX, MAX );
		setVisible ( true );
		addWindowListener ( this );
		addMouseListener ( this );
		addKeyListener ( this );
		
		
		//set up initial values
		lowX = -2.5;
		lowY = -2.5;
		highX = 2.5;
		highY = 2.5;
		x0 = 0.0;
		y0 = 0.0;
		
		for ( int i=0; i<max_iterations; i++){ iteration_array[i] = 0; }
	}


	//listen for mouse clicks
	// recenter calculation on mouse click
	public void mouseClicked ( MouseEvent e )
	{
		//mouse position in pixels
		int x = e.getX();
		int y = e.getY();
		
		//new center
		double length = highX - lowX;			//distance across screen in units
		double pixels_per_unit = MAX/length;	//number of pixels per unit
		double x_change = x/pixels_per_unit;
		double y_change =  y/pixels_per_unit;    // upside down but not relevent here
	
		x0 = lowX + x_change;
		y0 = lowY + y_change;
		
		//adjust the endpoints
		double change = MAX/( 2 * pixels_per_unit ) ; // ( midpoint/2 ) /pixels_per_unit = units to move 
		lowX = x0 - change;
		lowY = y0 - change;
		highX = x0 + change;
		highY = x0 + change;
		
		
		//need to recalculate and redraw now
		repaint();
	}
	

	//listen for key presses
	//  zoom in +
	//  zoom out -
	public void keyTyped ( KeyEvent e ) 
	{
		//zoom in
		if ( e.getKeyChar() == '+' ) {

			lowX /= 2.0;
			lowY /= 2.0;
			highX /= 2.0;
			highY /= 2.0;
			
		}else if ( e.getKeyChar() == '-' ) {
			
			lowX *= 2.0;
			lowY *= 2.0;
			highX *= 2.0;
			highY *= 2.0;
		}
		  
	
		//need to recalculate and redraw now
		repaint();
	}
	

	
	//draw the mandelbrot function
	public synchronized void paint ( Graphics g )
	{
		//clean up by painting screen black
		g.setColor ( Color.black );
		g.fillRect ( 0, 0, MAX, MAX );
	
		//mandelbrot z = z^2 + c 
		//   where c is a complex number x is real y is img
		double z_real, z_img, x, y;
		double z_magnitude = 0.0; 
		
		//we need this to convert pixels into numbers
		double length = highX - lowX;			//distance across screen in units
		double pixels_per_unit = MAX/length;	//number of pixels per unit
		
		//calculate numbers
		for ( int i=0; i<MAX; i++ ){
			
			x = lowX + i/pixels_per_unit;  //convert pixels to unit numbers
			
			for ( int j=0; j<MAX; j++){
			
				y = lowY + j/pixels_per_unit;  //convert pixels to unit numbers ( upside down but doesn't matter for this program! )
				int count = 0;   
				z_magnitude = 0.0;
				z_real = 0.0;
				z_img = 0.0;
				double z_real_old = 0.0;
				double z_img_old = 0.0;
				
				//actual mandelbrot calc
				// really checking that z_magnitude is < 2.0 but we are not calculating the sqrt so 
				// we can speed up the program - see note inside loop
				while (( z_magnitude < 4.0 ) && ( count < max_iterations )){
				
					//z = z^2 + [ x + yi ]  = Zreal * Zreal + 2*Zreal*Zimg - Zimg*Zimg =  [ Zreal*Zreal - Zimg*Zimg ] + [ 2 * Zreal * Zimg ]i
					z_real = ( z_real_old * z_real_old ) - ( z_img_old * z_img_old ) + x;
					z_img = 2 * z_real_old * z_img_old + y;
					
					
					count++;			// break out of loop if calc does not go to infinity
					
					z_real_old = z_real;
					z_img_old = z_img;
					
					// we're checking for |Z| < 2  
					//  but the square of 2 = 4 so we can skip the square root part and just
					//  see if z_real^2 + z_img^2 < 4
					//z_magnitude = Math.sqrt (z_real*z_real + z_img*z_img );
					z_magnitude = z_real*z_real + z_img*z_img;
					
					
				}// end while
				
				iteration_array[count-1] += 1;
				
				//System.out.println ( "Z: " + z_magnitude + "  loop: " + count + "   x: " + x + "   y: " + y );

				//ok we have our mandelbrot number now it needs a color
				// use the count from the loop not the value of the z_magnitude to pick a color
				
				if ( count < 10) {
					g.setColor ( Color.white );
				}else if ( count < 20 ){
					g.setColor ( Color.lightGray );
				}else if ( count < 30 ){
					g.setColor( Color.red );
				}else if ( count < 40 ){
					g.setColor ( Color.gray );
				}else if ( count < 50 ){
					g.setColor ( Color.darkGray );
				}else if ( count < 60 ){
					g.setColor ( Color.cyan);
				}else if ( count < 70 ) {
					g.setColor ( Color.yellow );
				}else if ( count < 80 ){
					g.setColor ( Color.orange );
				}else if ( count < 90 ){
					g.setColor (Color.magenta );
				}else if  ( count < 100 ){
					g.setColor ( Color.blue );
				}else if ( count < 990 ){
					g.setColor ( Color.green );
				}else{
					g.setColor( Color.black );
				}
				g.fillRect ( i, j, 1, 1 );
				
			}// end j loop
		}// end i loop
			
			//for ( int k=0; k<iterations; k++){
			//	if ( iteration_array[k] != 0 ){
			//		System.out.println ( "Iteration max: " + k + " number of times reached: " + iteration_array[k] );
			//	}
				
			//}
		
	}




	public synchronized void run(){}
	public void update ( Graphics g ) { paint(g); }
	public void windowOpened( WindowEvent ev ) {} 
    public void windowActivated( WindowEvent ev ) {} 
    public void windowIconified( WindowEvent ev ) {} 
    public void windowDeiconified( WindowEvent ev ) {} 
    public void windowDeactivated( WindowEvent ev ) {} 
    public void windowClosed( WindowEvent ev ) {} 
	public void mouseExited( MouseEvent e ){}
	public void mouseEntered( MouseEvent e ){}
	public void mousePressed ( MouseEvent e ){}
	public void mouseReleased ( MouseEvent e ){}
	public void mouseDragged ( MouseEvent e ){}
	public void mouseMoved ( MouseEvent e ){}
	public void keyPressed ( KeyEvent e ){}
    public void keyReleased ( KeyEvent e ){}


	//clean up
	public void windowClosing ( WindowEvent e )
	{	
		setVisible( false );
		dispose();
		System.exit( 0 );
		
	}

}//end class WindowDisplay