/***********************************************************************************
 * 
 * class:   floatImage
 * author: 	Mike Chantler
 * purpose: Represents an image as a nxm set of floats for each colour channel
 * Mods:    06/12/2008 MJC Created 
 * 
 * CONSTRUCTOR
 * - floatImage() 
 * 
 * METHODS
 * - betaNoise(n:int=512, beta:Number=2.0):void
 * - displayOnCanvas(c:Canvas,xRepeats:Number=1, yRepeats:Number=1):void
 * - fold():void
 * - illuminate(tau:int=0, sigma:int=20, htScaling:Number=1000):void
 * - loadInput(inIm:floatImage):void
 * - loadTestImage():void
 * - save2file():void{
 * - setSize(width:int, height:int, nChannels:int=1):void
 *
 ***********************************************************************************/
 package {
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import mx.controls.Image;
	
	import mx.containers.Canvas;
	public class FloatImage { //Monochrome floating point image
		[Embed(source='../assets/Image15g.jpg')] private var imClass:Class; //Used for testing
		public var height:int, width:int;
		public var nChannels:int=1;        //e.g. RGB image has 3 channels one for each colour
		private var imBitmap:Bitmap;       //Flash sprite (can be displayed but no pixel access
		private var imBD:BitmapData;       //24 or 32 bit image representation, allows acess vis getPixel() and setPixel()
		public var nPix:Array;             //Holds image as 1D+2D number array(extra dim for colour channels)
		public var unitNormal:FloatImage;  //Holds surface normals  
		
		// CONSTRUCTOR
		public function FloatImage(width:int=0, height:int=0, nChannels:int=1){ 
			if(width>0) setSize(width, height, nChannels);
		}
		
		// PUBLIC METHODS
		public function betaNoise(n:int=512, beta:Number=2.0):void{
		// Method to generate 1/f Beta noise in an nxn monochrome(single channel) floatImage
			var ndim:int=2; //2D image
			var dat:Array= new Array(2*n*n); //Used to hold the whole 2D DFT
			var obuf:Array=new Array(n), obufI:Array=new Array(n);
			var nn:Array=new Array(ndim+1);
			setSize(n, n, 1); //Set up space for spatial domain image
			//Declare real, imaginary and magnitue frequency domain images 
			//Note unswapped: so (aReal[0][0], aImag[0][0]) = d.c.
			var aReal:Array=new Array(n), aImag:Array=new Array(n), aMag:Array=new Array(n);
			for (i=0; i<n; i++) {
				aReal[i]=new Array(n); aImag[i]=new Array(n); aMag[i]=new Array(n);
			}
			
			var	l:int,ll:int,n2:int=n/2, i0:int,j0:int;
			var radcos:Number, radsin:Number;
			var p:Number, rad:Number, maxRad:Number=0, phase:Number;	 
	
			for (var i:int=0; i<=n2; i++) {
				for (var j:int=0; j<=n2; j++) {
					if ((i==0) && (j==0)) rad = 0.0; //zero dc 
					else {
						p=Math.sqrt(i*i + j*j);
						if (p <= 1.0) p = 1.0; rad = Math.pow(p,-beta);
					}
					phase = 2.0*Math.PI*Math.random()-Math.PI;
					radcos = rad * Math.cos(phase);
					radsin = rad * Math.sin(phase);
					aMag[i][j]=rad; if(rad>maxRad)maxRad=rad;
					aReal[i][j]=radcos; aImag[i][j]=radsin;
					
					//Now do complex conjugate
					if (i==0) i0=0; else i0=n-i;
					if (j==0) j0=0; else j0=n-j;
					aReal[i0][j0]= radcos; aImag[i0][j0]= -radsin;	//aMag [i0][j0]= rad; 			
				}			
			}
			aImag[n2][0] = aImag[0][n2] = aImag[n2][n2] = 0.0;
			for (i=1; i<=n2-1; i++) {
				for (j=1; j<=n2-1; j++) {
					phase = 2.0*Math.PI*Math.random() - Math.PI;
		 			p=Math.sqrt(i*i + j*j);
		 			if (p <= 1.0) p=1.0;
		 			rad = Math.pow(p,-beta);
		 			radcos = rad * Math.cos(phase); 	radsin = rad * Math.sin(phase);
		 			aReal[i][n-j]=radcos; 	 			aImag[i][n-j]=radsin;  			//aMag[i][n-j]=rad;
		 			//And complex conjugate:
		 			aReal[n-i][j]=  radcos;  			aImag[n-i][j]= -radsin; 		//aMag[n-i][j]=rad;	  
				}
			}
			
		    // Now inverse FFT: first reshuffle data into complex 1D array 'dat[]'
		    // Real data @ ll = 1, 3, 5, ..... 2*n*n -1
		    // Imag data @ ll+1 = ll = 2, 4, 6, ..... 2*n*n
			for (i=1; i<=n; i++){
				for (j=1; j<=n; j++){
					l = j + (i-1)*n; // l = 1, 2, 3, ... n*n
					ll = 2*l-1;      // ll = 1, 3, 5, ..... 2*n*n -1
					dat[ll]   = Number(aReal[i-1][j-1]); 	dat[ll+1] = Number(aImag[i-1][j-1]);
				}
			}
					
			// Do an inverse 2D transform 
			// nn[] is an integer array holding the length of each dimension 
			nn[1]=nn[2]=n; //note nn[0] not used as was fortran array?
	        fourn(dat,nn,ndim, 1);
			for (i=1; i<=n; i++) for (j=1; j<=n; j++){
				l = j + (i-1)*n; ll = 2*l-1;
				nPix[0][j-1][i-1] = Number(dat[ll]);
			}
		}
		public function getStats(channels:Array):Stats{
			var s:Stats=new Stats, min:Number, max:Number=nPix[channels[0]][0][0]; min=max;
			for (var i:int; i<channels.length; i++){
				var c:int=channels[i];
				for (var x:int=0; x<width; x++) for (var y:int=0; y<height; y++) 
					{var p:Number=nPix[c][x][y]; min=Math.min(min, p); max=Math.max(max, p);}	
			}
			s.max=max; s.min=min; s.scale=255/(max-min);
			return s;
		}
		public function displayChannelOnCanvas(c:Canvas, channel:int=0, scale:Number=1, offset:Number=0, xRepeats:Number=1, yRepeats:Number=1):void {
			//c = canvas that will be drawn upon
			//xRepeats = No of repeated tiles to draw horizontally, yRepeats = similar for verticle
			c.width=this.width; c.height=this.height;
			imBD=new BitmapData(width, height);	
				for (var x:int=0; x<width; x++) for (var y:int=0; y<height; y++){
					var pix:uint=Math.max(0, Math.min(255,(nPix[channel][x][y]+offset)*scale)); 
					pix=(256*pix+pix)*256+pix; 	imBD.setPixel(x,y,pix);
				}
			c.graphics.beginBitmapFill(imBD); c.graphics.drawRect(0,0,xRepeats*width,yRepeats*height); c.graphics.endFill();		
		}
		public function getBitmap(channel:int=0, scale:Number=1, offset:Number=0):Bitmap {
			imBD=new BitmapData(width, height);	
			for (var x:int=0; x<width; x++) for (var y:int=0; y<height; y++){
				var pix:uint=Math.max(0, Math.min(255,(nPix[channel][x][y]+offset)*scale)); 
				pix=(256*pix+pix)*256+pix; 	imBD.setPixel(x,y,pix);
			}
			var bm:Bitmap = new Bitmap(imBD);
			return bm;	
		}		
		public function getChannel(ch:Number=0):FloatImage{
			var c:FloatImage=new FloatImage(width, height, 1);
			for (var y:int=0; y<height; y++) for (var x:int=0; x<width-1; x++) c.nPix[0][x][y]=nPix[ch][x][y];		
			return c;
		}
		public function getUnitNormals(htScaling:Number=1000):FloatImage{
			// Calculates unit normals, n = [p, q, 1]/sqrt(1+p^2+q^2)
			// Where p & q are the partial derivatives p=dz/dx, q=dz/dy
			var n:FloatImage=new FloatImage(width, height, 3);
			var c:int=0; //Assumes height map in channel 0 of nPix;
			var iS:Number=1/htScaling; //invert for efficiency
			//Calculate p=dz/dx in channel 0
			for (var y:int=0; y<height; y++) { // calculate P(x,y)
				for (var x:int=0; x<width-1; x++) n.nPix[0][x][y] = (nPix[c][x+1][y] - nPix[c][x][y])*iS;	
				n.nPix[0][width-1][y] = (nPix[c][0][y] - nPix[c][width-1][y])*iS; //last column
			} 
			//Calculate q=dz/dy in channel 1
			for (x=0; x<width; x++) {
				for (y=0; y<height-1; y++) n.nPix[1][x][y] = (nPix[c][x][y]-nPix[c][x][y+1])*iS;	
				n.nPix[1][x][height-1] = (nPix[c][x][height-1] - nPix[c][x][0])*iS; //last row
			}
			//Calculate denominator in channel 2 & adjust p and q to provide unit normals
			for (x=0; x<width; x++) for (y=0; y<height; y++){
				var P:Number=n.nPix[0][x][y], Q:Number=n.nPix[1][x][y];
				n.nPix[2][x][y]=1.0/Math.sqrt(P*P+Q*Q+1);	
				n.nPix[0][x][y] *= n.nPix[2][x][y];	
				n.nPix[1][x][y] *= n.nPix[2][x][y];				
			}	
			return n;
		}
		public function getBitmapFromIlluminateNormals(tau:int=0, sigma:int=20, htScaling:Number=1):Bitmap{
			//Assumes 'this' holds unit surface normals (as produced by 'getUnitNormals')
			//htScaling = ration of x,y units to z units
			var img:FloatImage=new FloatImage(width, height, 1);
			var cs:Number=Math.cos(tau*Math.PI/180)*Math.sin(sigma*Math.PI/180); 
			var ss:Number=Math.sin(tau*Math.PI/180)*Math.sin(sigma*Math.PI/180); 
			var cos:Number=Math.cos(sigma*Math.PI/180); 		
			for (var x:int=0; x<width; x++) for (var y:int=0; y<height; y++){
				var pix:Number = (-nPix[0][x][y]*cs -nPix[1][x][y]*ss + nPix[2][x][y]*cos);
				img.nPix[0][x][y]=Math.max(0,  pix);				
			}		
			var s:Stats=img.getStats([0]);
			return img.getBitmap(0, s.scale, -s.min);		
		}		
		public function illuminateNormalsOnCanvas(c:Canvas, tau:int=0, sigma:int=20, htScaling:Number=1):void{
			//Assumes 'this' holds unit surface normals (as produced by 'getUnitNormals')
			//htScaling = ration of x,y units to z units
			var img:FloatImage=new FloatImage(width, height, 1);
			var cs:Number=Math.cos(tau*Math.PI/180)*Math.sin(sigma*Math.PI/180); 
			var ss:Number=Math.sin(tau*Math.PI/180)*Math.sin(sigma*Math.PI/180); 
			var cos:Number=Math.cos(sigma*Math.PI/180); 		
			for (var x:int=0; x<width; x++) for (var y:int=0; y<height; y++){
				var pix:Number = (-nPix[0][x][y]*cs -nPix[1][x][y]*ss + nPix[2][x][y]*cos);
				img.nPix[0][x][y]=Math.max(0,  pix);				
			}		
			var s:Stats=img.getStats([0]);
			img.displayChannelOnCanvas(c, 0, s.scale, -s.min);		
		}	
		public function illuminateNormalsOnCanvas2(c:Canvas, tau:int=0, sigma:int=20, htScaling:Number=1):void{
			//Assumes 'this' holds unit surface normals (as produced by 'getUnitNormals')
			//htScaling = ration of x,y units to z units
			var img:FloatImage=new FloatImage(width, height, 1);
			var cs:Number=Math.cos(tau*Math.PI/180)*Math.sin(sigma*Math.PI/180); 
			var ss:Number=Math.sin(tau*Math.PI/180)*Math.sin(sigma*Math.PI/180); 
			var cos:Number=Math.cos(sigma*Math.PI/180); 		
			for (var x:int=0; x<width; x++) for (var y:int=0; y<height; y++){
				var pix:Number = (-nPix[0][x][y]*cs -nPix[1][x][y]*ss + nPix[2][x][y]*cos);
				img.nPix[0][x][y]=Math.max(0,  pix);				
			}		
			var s:Stats=img.getStats([0]);
			img.displayChannelOnCanvas(c, 0, s.scale, -s.min);		
		}			
		public function loadInput(inIm:FloatImage):void{
			setSize(inIm.width, inIm.height, inIm.nChannels);
			for (var c:int=0; c<nChannels; c++) for (var x:int=0; x<width; x++) for (var y:int=0; y<height; y++) 
				this.nPix[0][x][y]=inIm.nPix[0][x][y];	
		}
		public function loadTestImage():void{
			imBitmap = new imClass();
			setSize(imBitmap.width, imBitmap.height, 1);
			imBD=new BitmapData(width, height);
			imBD.draw(imBitmap); //Copy image into bitmapData
			populate_nPix();
		}
		public function multImage(factor:Number):FloatImage{
			var img:FloatImage=new FloatImage(width, height, nChannels);
			for(var c:int=0; c<nChannels; c++) for (var x:int=0; x<width; x++) for (var y:int=0; y<height; y++){
				img.nPix[c][x][y]=factor*nPix[c][x][y];				
			}
			return img;
		}
		public function save2file():void{
			import mx.graphics.codec.*;
			import flash.utils.ByteArray;
			import flash.net.*;

            //Ref=http://digitalmedia.oreilly.com/pub/a/oreilly/digitalmedia/helpcenter/flex3cookbook/chapter8.html?page=6
            var bitmapData:BitmapData = new BitmapData(width, height);
            //bitmapData.draw(vid);
            var encode:JPEGEncoder = new JPEGEncoder(100);
            var ba:ByteArray = encode.encode(bitmapData);
            var urlRequest:URLRequest = new URLRequest("/jpg_reader.php");
            urlRequest.method = "POST";
            var urlVars:URLVariables = new URLVariables();
            urlVars.pic = ba;
            urlRequest.data = urlVars;
            flash.net.navigateToURL(urlRequest, "_blank");
            //http://apptools.com/phptools/force-download.php looks promising
            //check php code @ http://www.zeronese.net/knowledge-base/questions/1060/Image-Uploading-With-Auto-Thumbnails-Using-PHP
		}
		public function setSize(width:int, height:int, nChannels:int=1):void{
			this.height=height; this.width=width; this.nChannels=nChannels;
			nPix=new Array(nChannels);
			for (var c:int=0; c<nChannels; c++){
				nPix[c]=new Array(width);
				for (var x:int=0; x<width; x++) nPix[c][x]=new Array(height); 
			}
		}		
		// PRIVATE METHODS		
		private function fourn(data:Array,nn:Array,ndim:int,isign:int):void{
		// where ndat2 is twice the product of the transform lengths nn(i) 
			var	i1:int,i2:int,i3:int,i2rev:int,i3rev:int,ibit:int,idim:int;
			var	ip1:int,ip2:int,ip3:int,ifp1:int,ifp2:int,k1:int,k2:int,n:int;
			var	ii1:int,ii2:int,ii3:int;
			var	nprev:int,nrem:int,ntot:int;
			var	tempi:Number,tempr:Number;
			var	theta:Number,wi:Number,wpi:Number,wpr:Number,wr:Number,wtemp:Number;
		
			ntot = 1;
			for (idim=1; idim<=ndim; idim++) ntot = ntot*nn[idim];
			nprev = 1;
			for (idim=1; idim<=ndim; idim++) {
				n = nn[idim];
				nrem = ntot/(n*nprev);
				ip1 = 2*nprev;
				ip2 = ip1*n;
				ip3 = ip2*nrem;
				i2rev = 1;
				for (ii2=0; ii2<=((ip2-1)/ip1); ii2++) {
					i2 = 1+ii2*ip1;
					if (i2 < i2rev) {
						for (ii1=0; ii1<=((ip1-2)/2); ii1++) {
							i1 = i2+ii1*2;
							for (ii3=0; ii3<=((ip3-i1)/ip2); ii3++)	{
								i3 = i1+ii3*ip2; i3rev = i2rev+i3-i2;
								tempr = data[i3]; tempi = data[i3+1];
								data[i3] = data[i3rev]; data[i3+1] = data[i3rev+1];
								data[i3rev] = tempr; data[i3rev+1] = tempi;
							}
						}
					}
					ibit = ip2/2;
					while ((ibit >= ip1) && (i2rev > ibit)) {
						i2rev = i2rev-ibit;
						ibit = ibit/2;
					}
					i2rev = i2rev+ibit;
				}
				ifp1 = ip1;
				while (ifp1 < ip2) {
					ifp2 = 2*ifp1;
					theta = isign*2.0*Math.PI/(ifp2/ip1);
					wpr = -2.0*(Math.sin(0.5*theta)*Math.sin(0.5*theta));
					wpi = Math. sin(theta);
					wr = 1.0; wi = 0.0;
					for (ii3=0; ii3<=((ifp1-1)/ip1); ii3++)	{
						i3 = 1+ii3*ip1;
						for (ii1=0; ii1<=((ip1-2)/2); ii1++) {
							i1 = i3+ii1*2;
							for (ii2=0; ii2<=((ip3-i1)/ifp2); ii2++) {
								i2 = i1+ii2*ifp2;
								k1 = i2;
								k2 = k1+ifp1;
								tempr = wr*data[k2] - wi*data[k2+1]; tempi = wr*data[k2+1] + wi*data[k2];
								data[k2] = data[k1]-tempr;           data[k2+1] = data[k1+1]-tempi;
								data[k1] = data[k1]+tempr;           data[k1+1] = data[k1+1]+tempi;
							}
						}
						wtemp = wr;
						wr = wr*wpr-wi*wpi+wr;
						wi = wi*wpr+wtemp*wpi+wi;
					}
					ifp1 = ifp2;
				}
				nprev = n*nprev;
			}
		} 
		private function populate_nPix():void{
			//Note that a getter function for nPix seems to take too long when used in a 512x512 pixel loop
			for (var c:int=0; c<nChannels; c++) for (var x:int=0; x<width; x++) for (var y:int=0; y<height; y++) {
					nPix[c][x][y] = new Number; //force to Number for future floating point calculations
					nPix[c][x][y] = imBD.getPixel(x,y)&0xFF;
			}			
		}
	}
}