/** Buddhabrot Demo
  * by Xavier Gouchet, 2008
  * http://www.xgouchet.fr
  * xavier.gouchet@gmail.com
  */
  
// aerea settings
float top = 1.5;
float bottom = -1.5;
float left = -2.0;
float right = 1.0;

// mndlbrt settings
float step = 0.01;
float mstep = 0.01;
int limitR = 256;
int limitG = 64;
int limitB = 16;

// display settings
int width, height; 
int mwidth, mheight;

// grids
int[][][] mset;
int[][][] bset;

// Loop control
int x=0,y=0,pass=0;
int limit = max(max(limitR,limitG),limitB);

// color level
int mxR = 0, mxG = 0, mxB = 0;

void setup(){
	// Init frame settings
	width  = (int) ( (right - left) / step );
	height = (int) ( (top - bottom) / step );
	size(width,height);
	background(0);
    frameRate(120);
	
	// init grids
	mwidth  = (int) ( (right - left) / mstep );
	mheight = (int) ( (top - bottom) / mstep );
	mset = new int[mwidth][mheight][3];
	bset = new int[mwidth][mheight][3];
	
}

void draw(){
        //print (pass);
        //println (" -> ");
	switch (pass){
		case 0 : 
			mandelbrot();
			break;
		case 1 : 
			buddhabrot();
			break;
		case 2 : 
			exposure();
			break;
		default : 
			break;		
	}
}

void mandelbrot(){
	for (int l = 0; l<100; l++){
		if ((x<mwidth)&&(y<mheight)){
			// N = M?+ C
			float Cx = (x * mstep) + left;
			float Cy = (y * mstep) + bottom;
			float Mx = 0, My = 0, Nx = 0, Ny = 0;
			
			// init grid for this value
			bset[x][y][0] = 0;
			bset[x][y][1] = 0;
            bset[x][y][2] = 0;
			stroke(255);

			// mandelbrot main loop
			for (int k = 0; k<=limit; k++){
				// get N 
				Nx = (Mx*Mx) - (My*My) + Cx;
				Ny = (2*Mx*My) + Cy;

				// update Sets
				if (k<=limitR) 
				  mset[x][y][0] = k;
				if (k<=limitG)
				  mset[x][y][1] = k;
				if (k<=limitB) 
				  mset[x][y][2] = k;
                                  
				
				// test N?
				if ((Nx*Nx + Ny*Ny) > 4){
                                     stroke(96);
			             break;
                                }
				
				// decal 
				Mx = Nx;
				My = Ny;
			}
                        
			int i = (int) round((Cx-left)/step);
			int j = (int) round((Cy-bottom)/step);
			point(i,j);
		}
		
		// Inc X and Y
		x ++; 
		if (x>=mwidth){
			x=0; y++;
			if (y>= mheight){
				x = 0; y=0; pass++;
			}
		}
	}
}

void buddhabrot(){
	for (int l = 0; l<50; l++){
		if ((x<mwidth)&&(y<mheight)){
			if ( ( mset[x][y][0] < limit ) && ( mset[x][y][0] < limit ) && ( mset[x][y][2] < limit ) ){ // point is outside mand
				
				// N = M?+ C
				float Cx = (x * mstep) + left;
				float Cy = (y * mstep) + bottom;
				float Mx = 0, My = 0, Nx = 0, Ny = 0;
				
				// buddhabrot main loop
				for (int k = 0; k<limit; k++){
					// get N 
					Nx = (Mx*Mx) - (My*My) + Cx;
					Ny = (2*Mx*My) + Cy;
				
					// Expose N
					int gi = (int) round((Nx - left)/mstep);
					int gj = (int) round((Ny - bottom)/mstep);
					
					if ((gi>0)&&(gi<mwidth)&&(gj>0)&&(gj<mheight)){

						// Increment colors 
						if (k<limitR)
        						bset[gi][gj][0] = bset[gi][gj][0] + 10;
						if (k<limitG)
        						bset[gi][gj][1] = bset[gi][gj][1] + 10;
						if (k<limitB)
        						bset[gi][gj][2] = bset[gi][gj][2] + 10;

						// check levels
						if (mxR < bset[gi][gj][0])
							mxR = bset[gi][gj][0];
						if (mxG < bset[gi][gj][1])
							mxG = bset[gi][gj][1];
						if (mxB < bset[gi][gj][2])
							mxB = bset[gi][gj][2];
							
						// draw point
						stroke(bset[gi][gj][0],bset[gi][gj][1],bset[gi][gj][2]);
						int i = (int) round((Nx - left)/step);
						int j = (int) round((Ny - bottom)/step);
						point(i,j);
					}

					// decal 
					Mx = Nx;
					My = Ny;
				}
			}
		}
		
		// Inc X and Y
		x ++; 
		if (x>=mwidth){
			x=0; y++;
			if (y>= mheight){
				x = 0; y=0; pass++;
				println(mxR);
				println(mxG);
				println(mxB);
			}
		}
	}
}

void exposure(){
	for (int l = 0; l<100; l++){
		if ((x<mwidth)&&(y<mheight)){
			// Get Nearest Color
			float avR = 0;
			float avG = 0;
			float avB = 0;
			
			float count = 0;
			for (int i = -1; i<=1; i++){
				int nx = x+i;
				for (int j=-1; j<=1; j++){
					int ny = y+j;
					if ( (nx>=0) && (nx<mwidth) && (ny>=0) && (ny<mheight) ){
						avR += ((bset[nx][ny][0] * 255) / mxR);
						avG += ((bset[nx][ny][1] * 255) / mxG);
						avB += ((bset[nx][ny][2] * 255) / mxB);
                                                float weight = 2 - sqrt((i*i) + (j*j));
                                                count += weight*weight;
					}
				}
			}
			int pow = 5;
			avR += pow*((bset[x][y][0] * 255) / mxR);
			avG += pow*((bset[x][y][1] * 255) / mxG);
			avB += pow*((bset[x][y][2] * 255) / mxB);
			count += pow;

			// level colors
			int r = (int) (avR / count);
			int g = (int) (avG / count);
			int b = (int) (avB / count);
			
			// get nearest pixel
			int i = (int) round((x * mstep)/step);
			int j = (int) round((y * mstep)/step);
			
			// draw point
			stroke(r,g,b,128);
			point(i,j); 
			
		}
		
		// Inc X and Y
		x ++; 
		if (x>=mwidth){
			x=0; y++;
			if (y>= mheight){
				x = 0; y=0; pass++;
			}
		}
	}
}