/*
* script original ici:
* http://labs.blitzagency.com/?p=118
* 
* mon commentaire incroyable 
* http://labs.blitzagency.com/?p=118#comment-8026
* 
* 
* 
*/
package  {
	
	import flash.display.BitmapData;

	public class Polarize{
		
		static public var polarBitmap:BitmapData
		
		public function Polarize(){}
		/*
		* version optimisée -30% de temps de calcul 
		*/
		/*
		*/
		static public function convertBitmapData( image:BitmapData, resize:Boolean=false, rayon:int=2 ):BitmapData
		{
			//recupere largeur et hauteur
			var W:int = image.width;
			var H:int = image.height;
			
			//trouve le cote le plus court et deduis le rayon maximum 
			var dim:int = ( W < H ) ? W : H;
			
			//rayon de la polarisation
			var radius:Number = 0;
			
			//position du centre
			var CX:int = 0;
			var CY:int = 0;
			
			// cree le bitmap final
			// redéfinit les dimensions du bitmap final selon qu'on le resize ou pas :
			if ( resize )
			{
				Polarize.polarBitmap = new BitmapData(	dim, dim, true,	0x00000000 );
				CX = dim 	>> 1;
				CY = dim	>> 1;
				radius = dim / rayon;
				
			}else{
				
				
				Polarize.polarBitmap = new BitmapData(	W, H, true,	0x00000000 );
				CX = W >>1;
				CY = H >>1;
				radius = dim / rayon;
				
			}
			
			
			//ints
			var DX:int, DY:int, cartesianX:int, cartesianY:int;
			
			// uints
			var color:uint; 
			
			//numbers
			var hypothenuse:Number, radians:Number, degres:Number, inverseDegres:Number
			
			var Y:int = H
			while(Y--)
			{
				var X:int = W
				while(X--)
				{
					// prend la position de chaque pixel par rapport au centre
					DX = X - CX;
					DY = Y - CY;
					
					// calcule la distance pixel - centre
					hypothenuse  = Math.sqrt( DX * DX + DY * DY );
					
					// trouve l'angle
					radians = Math.atan2( DY, DX );
					
					// passe en degres
					degres = radians * 180 / Math.PI + 90;
					
					// offset pour l'angle
					degres = (degres<0)?degres+360:(degres>360)?degres-360:degres;
					
					// angle complementaire
					inverseDegres = 360 - degres;
					
					
					// trouve les coordonnees du pixel dont on preleve la couleur
					// le truc que je n'avais pas compris dans mes precedentes tentatives
					
					cartesianX = inverseDegres * W / 360 ; 
						//marche aussi
						//var cartesianX:int = degres * W / 360 ; 
						
					cartesianY = hypothenuse * H / radius ;
					
					
					
					//	rabat sur l'avant dernier pixel en hauteur ou en largeur lorsque 
					//	X OU Y atteignent ou depassent la largeur ou la hauteur					
					if(	cartesianX > W-1 )	cartesianX  = W -1;
					if(	cartesianY > H-1 )	cartesianY  = H -1;
					
					//preleve 
					color = image.getPixel32(cartesianX,cartesianY);
					
					//assigne une couleur arbitraire quand on depasse le cercle de centre CX / CY :
				//	if( hypothenuse > radius ) color = 0x00000000;
					
					//assigne la couleur prelevee au coordonnees X, Y 
					polarBitmap.setPixel32( X, Y, color );
					
				}
			}
			return polarBitmap;
		}
		
		/*
		* version originale déja bien tranchante pour pour comparer :
		*/
		/*
		*/
		public static function originalConvertBitmapData(image:BitmapData):BitmapData{
			var imageWidth:Number = image.width;
			var imageHeight:Number = image.height;
			var radius:Number = imageWidth/2;
			var xCenter:Number = Math.round(imageWidth/2);
			var yCenter:Number = Math.round(imageHeight/2);
			var polarBitmap:BitmapData = new BitmapData(imageWidth,imageHeight,true,0x00000000);
			for(var yPos:Number=0;yPos<imageHeight;yPos++){
				for(var xPos:Number=0;xPos<imageWidth;xPos++){
					var xTrue:Number = xPos - xCenter;
					var yTrue:Number = yPos - yCenter;
					var hypothenuse:Number = Math.sqrt((xTrue*xTrue)+(yTrue*yTrue));
					//hypothenuse = (hypothenuse>radius)?radius-1:hypothenuse;
					var radians:Number = Math.atan2(yTrue, xTrue);
					var degrees:Number = radians*180/Math.PI + 90;
					degrees = (degrees<0)?degrees+360:degrees;
					degrees = (degrees>360)?degrees-360:degrees;
					var invertedDegrees:Number = 360 - degrees;
					var circonference:Number = 2*Math.PI*hypothenuse;
					var cartesianX:Number = Math.round(invertedDegrees*imageWidth/360);
					var cartesianY:Number = Math.round(hypothenuse*imageHeight/radius);
					cartesianX = (cartesianX>=imageWidth)?imageWidth-1:cartesianX;
					cartesianY = (cartesianY>=imageHeight)?imageHeight-1:cartesianY;
					var color:uint = image.getPixel32(cartesianX,cartesianY);
					polarBitmap.setPixel32(xPos,yPos,color);
				}
			}
			return polarBitmap;
		}
    }
}