MAth-Cloud-3.0.0/www.ipsocloud.com/intimamedia.com/flex/com/imt/intimamedia/helpers/ScaleCJ.as

package com.imt.intimamedia.helpers
{
 	import flash.display.*;
 	import flash.geom.Point;
 	import flash.text.TextField;
 	import flash.text.TextFormat;
 	
 	import mx.controls.Alert;
	
	// Added by Jdeppe march 2012
	// CJ suffix because first coder of Scale object (IMT V1) was Christophe Jacquelin
	// IMT Paris Opera district
	public class ScaleCJ
	{
		private var m_ptClick0:PointCJ = new PointCJ();	// Point du premier click souris 	 
		private var m_ptClick1:PointCJ = new PointCJ();	// Point du 2ème click souris 
			 
		private var m_dblDistance:Number;	// Distance en pixels entre les 2 points de l'échelle
  		
		public var m_nbPoints:int;	// Nombre de points de l'échelle
 	
 		[ArrayElementType("PointCJ")]
		public var m_points:Array = new Array(512); 
 
		private var m_found:Boolean;	// Une échelle a été détectée 
  		
		public var m_length:int;	// Longueur Echelle  

		private var m_label:TextField = new TextField();
  		
		private var m_x1debug:int; 
		private var m_x2debug:int; 
  		
		public function ScaleCJ()
		{
			var i:int; 
			
			m_found = false;
			m_label.x = 0; 
			m_label.y = 0; 

 			for (i = 0; i < 512; i++)
  			{
				m_points[i] = new PointCJ();
				m_points.x = 0;
				m_points.y = 0;
  			}

			m_nbPoints = 0;
 		  	
 		  	m_ptClick0.x = 0; 
 		  	m_ptClick0.y = 0; 		  	

		  	m_ptClick1.x = 0; 
 		  	m_ptClick1.y = 0;  		  	
 		}
		
		public function getXFirstPoint() : int
		{
			return m_points[0].x;
		}
		
		public function getYFirstPoint() : int
		{
			return m_points[0].y;
		}
		
		public function getXLastPoint() : int
		{
			return m_points[m_nbPoints-1].x;
		}
		
		public function getYLastPoint() : int
		{
			return m_points[m_nbPoints-1].y;
		}

		public function setClickPoints(x1:int, y1:int, x2:int, y2:int):void
		{
			m_ptClick0.x = x1;
			m_ptClick0.y = y1; 

			m_ptClick1.x = x2;
			m_ptClick1.y = y2;
		}
		
		public function setPoints(x1:int, y1:int, x2:int, y2:int):void
		{
			m_points[0].x = x1;
			m_points[0].y = y1; 
			
			m_points[1].x = x2;
			m_points[1].y = y2;
		}
		
		public function setLength(length : int) : void
		{
			m_length = length;
		}
		
		public function getLength(): int
		{
			return m_length;
		}
		
		public function setNbPoints(nbPoints:int) : void
		{
			m_nbPoints = nbPoints;
		}
		
		public function setScaleFound(found:Boolean) : void
		{
			m_found = found;
		}
		
		public function setDistance(distance:Number) : void
		{
			m_dblDistance = distance;
		}
		
		public static function pointxOriginalToResize(x:int, oridimh:int, oridimv:int, resizedimh:int):int
		{
			var result:int;
			var ratio : Number; 
			var newdimh : int;
			var newdimv : int; 
			var y : int ; 
			
			ratio = Number(oridimh) / Number(oridimv); 
			
			if (ratio <= (4.0 / 3.0))
			{
				newdimv = oridimv;
				newdimh = int((4.0 * oridimv) / 3.0); 
			}
			else 
			{
				newdimh = oridimh;
				newdimv = int ((3.0 * oridimh) / 4.0);
			}	
			
			if (newdimv >= oridimv)
			{
				// ------------
				//
				// ------------
				// xxxxxxxxxxxx
				// ------------
				//
				// ------------
//				x = x;  
				x = x + ((newdimh - oridimh) / 2);  
				y = y + ((newdimv - oridimv) / 2);
			}
			else if (newdimh >= oridimh)
			{
				// |  | x |   |
				// |  | x |   |
				// |  | x |   |
				// |  | x |   |
				// |  | x |   |
				// |  | x |   |
				//				Alert.show("newdimh > dimh");
				x = x + ((newdimh - oridimh) / 2);  
				y = y + ((newdimv - oridimv) / 2);
//			y = y;
			}	
			
			x = (x * resizedimh) / newdimh;
			
			return x; 
		}
		
		public  static function pointyOriginalToResize(y:int, oridimh:int, oridimv:int, resizedimv:int ):int
		{
			var result:int;
			var ratio : Number; 
			var newdimh : int;
			var newdimv : int; 
			var x : int ; 
			
			ratio = Number(oridimh) / Number(oridimv); 
			
			if (ratio <= (4.0 / 3.0))
			{
				newdimv = oridimv;
				newdimh = int((4.0 * oridimv) / 3.0); 
			}
			else 
			{
				newdimh = oridimh;
				newdimv = int ((3.0 * oridimh) / 4.0);
			}	
			
			if (newdimv >= oridimv)
			{
				// ------------
				//
				// ------------
				// xxxxxxxxxxxx
				// ------------
				//
				// ------------
//				x = x;  
				x = x + ((newdimh - oridimh) / 2);  
				y = y + ((newdimv - oridimv) / 2);
			}
			else if (newdimh >= oridimh)
			{
				// |  | x |   |
				// |  | x |   |
				// |  | x |   |
				// |  | x |   |
				// |  | x |   |
				// |  | x |   |
				//				Alert.show("newdimh > dimh");
				
				x = x + ((newdimh - oridimh) / 2);  
				y = y + ((newdimv - oridimv) / 2);
//				y = y;
			}	
			
			y = (y * resizedimv) / newdimv;
			
			return y; 
		}
		
		// Dessine l'échelle
		public function onDraw(origdimh:int, origdimv:int, resizeedimh:int, resizeedimv:int, graph:Graphics):void
		{	
  			var point1:PointCJ = new PointCJ();
 			var point2:PointCJ = new PointCJ();
 			var i:int;
 			var direction:int;

 			if (m_found == true)
			{
	 			if (m_points[0].x < 384)
				{
					direction = 1;
				}
				else
				{
					direction = -1;
				}

				graph.lineStyle(2, 0x00ff00, 1);
				
				point1.x = m_points[0].x; 
				point1.y = m_points[0].y; 
				point1.y -= 4; 
				
				point2.y = m_points[m_nbPoints - 1].y; 
				point2.x = m_points[0].x;
				point2.y += 4;	

				graph.moveTo( pointxOriginalToResize(point1.x, origdimh, origdimv, resizeedimh), pointyOriginalToResize(point1.y, origdimh, origdimv, resizeedimv));
				graph.lineTo( pointxOriginalToResize(point2.x, origdimh, origdimv, resizeedimh), pointyOriginalToResize(point2.y, origdimh, origdimv, resizeedimv));
//				graph.moveTo(point1.x, point1.y);
//				graph.lineTo(point2.x, point2.y);

				for (i = 0; i < m_nbPoints; i++)
				{
					if ((i == 0) || (i == m_nbPoints - 1))
					{
						graph.lineStyle(1, 0xf98d00, 1); // orange
					}
					else
					{
						graph.lineStyle(1, 0x00ff00, 1); // green
					}

					point1.x = m_points[i].x;
					point1.y = m_points[i].y;
					point2.x = m_points[i].x;
					point2.y = m_points[i].y;

					if ((i == 0) || (i == m_nbPoints - 1))
					{
						point1.x = m_points[0].x - 30; 
						point2.x = m_points[0].x; 
					}
					else
					{
						point1.x = m_points[0].x - 4; 
						point2.x = m_points[0].x; 
					}

//					graph.moveTo(point1.x, point1.y);
//					graph.lineTo(point2.x, point2.y);
					graph.moveTo( pointxOriginalToResize(point1.x, origdimh, origdimv, resizeedimh), pointyOriginalToResize(point1.y, origdimh, origdimv, resizeedimv));
					graph.lineTo( pointxOriginalToResize(point2.x, origdimh, origdimv, resizeedimh), pointyOriginalToResize(point2.y, origdimh, origdimv, resizeedimv));

					if ((i == 0) || (i == m_nbPoints - 1))
					{
						point2.y = m_points[i].y; 
						point2.x = m_points[0].x; 
//						graph.moveTo(point2.x, point2.y);
						graph.moveTo( pointxOriginalToResize(point2.x, origdimh, origdimv, resizeedimh), pointyOriginalToResize(point2.y, origdimh, origdimv, resizeedimv));
						
						point1.x = point2.x - 4; 
						point1.y = point2.y - 4; 
						
//						graph.lineTo(point1.x, point1.y);
//						graph.moveTo(point2.x, point2.y);
						graph.moveTo( pointxOriginalToResize(point1.x, origdimh, origdimv, resizeedimh), pointyOriginalToResize(point1.y, origdimh, origdimv, resizeedimv));
						graph.lineTo( pointxOriginalToResize(point2.x, origdimh, origdimv, resizeedimh), pointyOriginalToResize(point2.y, origdimh, origdimv, resizeedimv));

						point1.y = point2.y + 4; 
//						graph.lineTo(point1.x, point1.y);
						graph.lineTo( pointxOriginalToResize(point1.x, origdimh, origdimv, resizeedimh), pointyOriginalToResize(point1.y, origdimh, origdimv, resizeedimv));
					}
				}
			}
 		}
	
		public function distanceCalculation(pt1:PointCJ, pt2:PointCJ):Number
		{
			var dist:Number = new Number;
			
			dist = Math.sqrt(((pt2.x - pt1.x) * (pt2.x - pt1.x) + (pt2.y - pt1.y) * (pt2.y - pt1.y)));
			
			return dist; 
		}
		
		// Calcul de l'échelle 
		public function calculation(vImage:ImageCJ):int
 		{
 			var point1:PointCJ = new PointCJ();
 			var point2:PointCJ = new PointCJ();
 			var point3:PointCJ = new PointCJ();
 			var i:int;
 			var rep:int;
 			var maxNg:int;
 			var maxTotal:int;
  			var deltax:int;
 			var dwPos:int;
			var ng:int;
			var nPts:int; 
 			var saveDetection:Boolean; 
 			var detection:Boolean;
 			var minPos:int;
 			var maxPos:int;
 			var color:uint;
 			var red:uint;
 			var green:uint; 
 			var blue:uint; 
 			var val:Number; 
 			var idx:int;
			var direction:int; 
			var ng1:int;
			var ng2:int;
			var ng3:int;
 			var ptClick0:PointCJ = new PointCJ();
 			var ptClick1:PointCJ = new PointCJ();

			ptClick0.x = m_ptClick0.x;
			ptClick0.y = m_ptClick0.y;
			ptClick1.x = m_ptClick1.x;
			ptClick1.y = m_ptClick1.y;

			 			 			
	 		if (ptClick0.y > ptClick1.y)
	 		{
	 			point1.x = ptClick1.x;
	 			point1.y = ptClick1.y;
	 			ptClick1.x = ptClick0.x;
	 			ptClick1.y = ptClick0.y;
	 			ptClick0.x = point1.x;
	 			ptClick0.y = point1.y;
	 		}

			if (ptClick1.x < 384)
			{
				direction = 1; 
			}
			else
			{
				direction = -1; 
			}
			
			m_x1debug = ptClick1.x + 4 * direction; 
			m_x2debug = ptClick1.x + 3 * direction;
			
 			rep = -1; 

			nPts = ptClick1.y - ptClick0.y;

			if (nPts > 2) 
			{
	 			for (idx = ptClick1.x + 3 * direction; ((((direction == 1) && (idx < ptClick1.x + 6)) || ((direction == -1) && (idx > ptClick1.x - 6))) && (rep < 2)); idx+=direction)
	 			{			
		 			for (i = 0; i < 512; i++)
		  			{
						m_points.x = 0;
						m_points.y = 0;
		  			}
		  			
					m_nbPoints = 0;
		  		  	
					m_found = false;
		  
					var histogram:Array = new Array(1024); 
					var mark:Array = new Array(1024); 
		 			 			
					point2.x = idx;	
					point2.y = ptClick1.y;	
		 								
		 			for (i = 0; i < 1024; i++) 
		 			{ 
						mark[i] = 0;
		 				histogram[i] = 0;  
		 			}
		 				
		 			maxTotal = 0; 
		 			for (dwPos = 0; dwPos < nPts; dwPos++) 
		 			{	
		  				point1.x = idx;
		  				point1.y = ptClick0.y + dwPos; 
		  				
		 				point2.y = point1.y; 

	 					// On prend la valeur maxi sur une largeur de 10 pixels à chaque point 
		 				// Et sur une épaisseur de 3 pixels
		 				maxNg = 0; 
		 		 
		 				for (deltax = -5; deltax <= 5; deltax++) 
		 				{
		 					point2.x = point1.x + deltax - 1;
		 					color = vImage.data.getPixel(point2.x, point2.y);
		 					red = color >> 16 & 0xFF;
		 					green = color >> 8 & 0xFF;
		 					blue = color & 0xFF; 					
		 					ng1 = ((red + green + blue) / 3); 
	
		 					point2.x = point1.x + deltax;
							color = vImage.data.getPixel(point2.x, point2.y);
							red = color >> 16 & 0xFF;
							green = color >> 8 & 0xFF;
							blue = color & 0xFF; 					
		 					ng2 = ((red + green + blue) / 3); 
	
		 					point2.x = point1.x + deltax + 1;
							color = vImage.data.getPixel(point2.x, point2.y);
							red = color >> 16 & 0xFF;
							green = color >> 8 & 0xFF;
							blue = color & 0xFF; 					
		 					ng3 = ((red + green + blue) / 3); 
		 					 	
		 					ng = (ng1 + ng2 + ng3) / 3;
		 					 					
		 					if (ng > maxNg) 
		 					{
		 						maxNg = ng;
		 					}
		 					
		 					if (ng > maxTotal) 
		 					{
		 						maxTotal = ng;
		 					}
		 				}
			 				
		 				histogram[dwPos] = maxNg;
		 			}
		 			
		 			// Affiche les 2 points extrêmes que l'on a détecté
		 			saveDetection = false; 
		 			rep = 0; 
		 			for (i = 0; i < nPts; i++)
		 			{
		 				if (maxTotal >= 220)
		 				{
		 					// Cas standard où l'echelle se voit bien en blanc
		 					if (histogram[i] > 219)   
		 					{
		 						detection = true; 
		 					}
		 					else
		 					{
		 						detection = false; 
		 					}
						}		
		 				else
		 				{
		 					// Cas où les images ont une echelle ayant un éclairement plus faible
		 					if ((histogram[i] > (maxTotal - 50)) && (histogram[i] > 120))
		 					{
		 						detection = true; 
		 					}
		 					else
		 					{
		 						detection = false; 
		 					}
						} 			 
		 			
			 			if (detection == true)
			 			{
			 				if (saveDetection == false)
			 				{
			 					minPos = i;
								saveDetection = true; 
			 				}	
			 			}
			 			else
			 			{
			 				if (saveDetection == true)
			 				{
			 					maxPos = i - 1;
			 					val = (maxPos + minPos) / 2.0;
			 					mark[rep] = Math.round(val);
			 					rep++; 
								saveDetection = false; 
			 				}
			 			} 	
		 			}
			 	 	
			 	 	for (i = 0; i < rep; i++)
			 		{
			 			point3.x = ptClick0.x; 
			 			point3.y = ptClick0.y + mark[i];
						m_points[i].x = point3.x; 
						m_points[i].y = point3.y; 
			 		}
					
					if (rep > 1)
					{
						m_dblDistance = distanceCalculation(m_points[0], m_points[rep - 1]);
						m_found = true; 
						m_nbPoints = rep;
					}
					else
					{
						m_found = false;
					} 
				}
 			}
			
			return rep;
		}
		
		private function clean(graph:Graphics, vSprite:Sprite):void
		{		
			graph.clear();		
			if (vSprite.numChildren)
				vSprite.removeChildAt(0);		
		}	
		
		// Dessine l'echelle superposée à l'image
		public function draw(origdimh:int, origdimv:int, resizeedimh:int, resizeedimv:int, graph:Graphics, vImage:ImageCJ, vSprite:Sprite):void
 		{
  			var vp1:PointCJ = new PointCJ();
 			var vp2:PointCJ = new PointCJ();
  			var sens:int; 
			var startX:int; 
			var startY:int; 

	 		if ((m_nbPoints > 0) && (m_found == true)) 
			{			
				if (m_points[0].x < 384)
				{
					sens = 1;
				}
				else
				{
					sens = -1; 
				}
				
	  			this.clean(graph, vSprite);
				graph.lineStyle(2, 0x00ff00, 1); // vert
 				
// 				graph.moveTo(m_points[0].x, m_points[0].y);
// 				graph.lineTo(m_points[m_nbPoints - 1].x, m_points[m_nbPoints - 1].y);
				graph.moveTo( pointxOriginalToResize(m_points[0].x, origdimh, origdimv, resizeedimh), pointyOriginalToResize(m_points[0].y, origdimh, origdimv, resizeedimv));
 				graph.lineTo( pointxOriginalToResize(m_points[m_nbPoints - 1].x, origdimh, origdimv, resizeedimh), pointyOriginalToResize(m_points[m_nbPoints - 1].y, origdimh, origdimv, resizeedimv));
		
				graph.lineStyle(2, 0x00ff00, 1); // vert
 
				vp1.x = m_points[0].x; 
				vp1.y = m_points[0].y; 
				vp2.x = m_points[0].x; 
				vp2.y = m_points[0].y;
				 
				vp1.x -= 6;
				vp2.x += 6;
				
	//			graph.moveTo(vp1.x, vp1.y); 
	//			graph.lineTo(vp2.x, vp2.y); 
				graph.moveTo( pointxOriginalToResize(vp1.x, origdimh, origdimv, resizeedimh), pointyOriginalToResize(vp1.y, origdimh, origdimv, resizeedimv));
				graph.lineTo( pointxOriginalToResize(vp2.x, origdimh, origdimv, resizeedimh), pointyOriginalToResize(vp2.y, origdimh, origdimv, resizeedimv));
						
				vp1.x = m_points[m_nbPoints - 1].x; 
				vp1.y = m_points[m_nbPoints - 1].y; 
				
				vp2.x = m_points[m_nbPoints - 1].x; 
				vp2.y = m_points[m_nbPoints - 1].y; 
				
				vp1.x -= 6;
				vp2.x += 6;
	
//				graph.moveTo(vp1.x, vp1.y); 
//				graph.lineTo(vp2.x, vp2.y); 
				graph.moveTo( pointxOriginalToResize(vp1.x, origdimh, origdimv, resizeedimh), pointyOriginalToResize(vp1.y, origdimh, origdimv, resizeedimv));
				graph.lineTo( pointxOriginalToResize(vp2.x, origdimh, origdimv, resizeedimh), pointyOriginalToResize(vp2.y, origdimh, origdimv, resizeedimv));
		
				vp1.x = m_points[0].x; 
				vp1.y = m_points[0].y; 
				
				vp1.x -= 20; 
				
				vp1.y = (m_points[m_nbPoints - 1].y + m_points[0].y) / 2 - 10; 

				startX = pointxOriginalToResize(vp1.x, origdimh, origdimv, resizeedimh); 
				startY = pointyOriginalToResize(vp1.y, origdimh, origdimv, resizeedimv); 
				
				vp1.x = startX;
				vp1.y = startY;
				
				var format:TextFormat = new TextFormat();
				format.font = "Arial";
				format.color = 0xf98d00;
				format.size = 14;
				format.underline = false;
				format.bold = false;
				
       			// Affiche la valeur de l'échelle sélectionnée							
				m_label.text = m_length.toString(); 
				m_label.x = vp1.x;  
				m_label.y = vp1.y;
				m_label.width = 40; 
				m_label.height = 35;
    			m_label.defaultTextFormat = format;
       			m_label.setTextFormat(format);
				      						 
				vSprite.addChild(m_label);
			}
 		}
 	}
}