package com.insanityengine.ghia.m3;
   
   /***
    *
    * <P>
    * I wrote this class back in 1999! It is still pretty handy.
    * Here are the original comments:
    * </P>
    *
   * <PRE>
   * since java.awt.Point is integer based...  
   * also add some handy routines:
   * 	- rotate around a given point at given angle
   * 	- find the distance from another point 
   * 	- calculate the angle from another point
   * </PRE>
   **/
  
  import java.awt.*;
  
  public class Pt2 {
  	
  	
  	/***
  	 *
  	 * Constructor
  	 *
  	 */
  	public Pt2() {
  		x = y = 0;
  	}
  	
  	/***
  	 *
  	 * Constructor
  	 *
  	 * @param x coordinate
  	 * @param y coordinate
  	 *
  	 */
  	public Pt2( double x, double y ) {
  		setX( x );
  		setY( y );
  	}
  	
  	/***
  	 *
  	 * Constructor
  	 *
  	 * @param point
  	 *
  	 */
  	public Pt2( Pt2 point ) {
  		set( point );
  	}
  	
  	/***
  	 *
  	 * Constructor
  	 *
  	 * @param point
  	 *
  	 */
  	public Pt2( Point point ) {
  		set( point );
  	}
  
  	/***
  	 *
  	 * Equality operator
  	 *
  	 * @param x coordinate
  	 * @param y coordinate
   	 * 
   	 * @return true if equal, else false
  	 *
  	 */
  	public boolean equals( double x, double y ) {
  		return ( x == this.x && y == this.y );
  	}
  	
  	/***
  	 *
  	 * Equality operator
  	 *
  	 * @param point to compare
   	 * 
   	 * @return true if equal, else false
  	 *
  	 */
  	public boolean equals( Pt2 point )  { 
  		return equals( point.getX(), point.getY() ); 
  	}
  	
  	/***
  	 *
  	 * Equality operator
  	 *
  	 * @param point to compare
  	 * 
  	 * @return true if equal, else false
 	 *
 	 */
 	public boolean equals( Point point ) { 
 		return equals( point.getX(), point.getY() ); 
 	};
 	
 	/***
 	 *
 	 * "Equality" operator
 	 *
 	 * @param x coordinate
 	 * @param y coordinate
 	 * @param errFactor to use
  	 * 
  	 * @return true if equal, else false
 	 *
 	 */
 	public boolean equals( double x, double y, double errFactor ) {
 		return (
 			Math.abs( this.x - x ) <= errFactor 
 		) && (
 			Math.abs( this.y - y ) <= errFactor
 		);
 	}
 	
 	/***
 	 *
 	 * "Equality" operator
 	 *
 	 * @param point to compare
 	 * @param errFactor to use
  	 * 
  	 * @return true if equal, else false
 	 *
 	 */
 	public boolean equals( Pt2 point, double errFactor )  { 
 		return equals( point.getX(), point.getY(), errFactor );
 	}
 	
 	/***
 	 *
 	 * "Equality" operator
 	 *
 	 * @param point to compare
 	 * @param errFactor to use
  	 * 
  	 * @return true if equal, else false
 	 *
 	 */
 	public boolean equals( Point point, double errFactor ) { 
 		return equals( point.getX(), point.getY(), errFactor );
 	}
 
 	/***
 	 *
 	 * create Point equivalent
 	 *
 	 * @return Point equivalent
 	 *
 	 */
 	public Point toPoint() {
 		return new Point(
 			( int ) x
 			,
 			( int ) y
 		);
 	}
 
 	/***
 	 *
 	 * create String equivalent
 	 *
 	 * @return String equivalent
 	 *
 	 */
 	public String toString() {
 		return "[Pt2, x=" + x + ", y=" + y + "]";
 	}
 
 	/***
  	 *	  
  	 * Translate this point
  	 *	  
  	 * @param tx value	  
  	 * @param ty value	  
  	 *	  
  	 */
 	public void translate( double tx, double ty ) {
 		x += tx; 
 		y += ty;
 	}
 
 	/***
 	 *
  	 * Rotate this point around another by a certain angle
  	 *	  
  	 * @param x coordinate
  	 * @param y coordinate
  	 * @param angle to rotate by
  	 *	  
  	 */
 	public void rotate( double x, double y, double angle ) {
 		double dist=distance(x,y);
 		this.x=x+dist*Math.cos(angle);
 		this.y=y+dist*Math.sin(angle);
 	}
 	
 	/***
 	 *
 	 * Get the square of the distance to a point
 	 *
 	 * @param x coordinate
 	 * @param y coordinate
 	 *
 	 * @return square of the distance
 	 *
 	 */
 	public double dist2( double x, double y ) {
 		return (
 			( this.x - x ) * ( this.x - x )
 			+
 			( this.y - y ) * ( this.y - y )
 		);
 	}
 
 	/***
 	 *
 	 * Get the distance to a point
 	 *
 	 * @param x coordinate
 	 * @param y coordinate
 	 *
 	 * @return distance
 	 *
 	 */
 	public double distance( double x, double y ) {
 		return Math.sqrt( dist2( x, y ) );
 	}
 
 	public String uh( String s ) { 
 		int idx = s.indexOf( "." ) + 4;
 		if ( idx >= s.length() ) idx = s.length();
 		return s.substring( 0, idx );
 	}
 
 	public String oh( double d ) {
 		return uh( "" + d );
 	}
 	
 	/***
 	 *
 	 * Get the angle to a point
 	 * Revised thx to http://www.geocities.com/SiliconValley/2151/math2d.html
 	 *
 	 * @param x coordinate
 	 * @param y coordinate
 	 *
 	 * @return the angle
 	 *
 	 */
 	public double getAngle( double x, double y ) {
 /*
 		// A * B = Ax*Bx + Ay*By
 		// If A and B are unit vectors then the 
 		// dot product is the cosine of the angle 
 		// between them, so the angle itself (theta) 
 		// can be calculated by taking the inverse cosine of the dot product:
 		//
 		// theta = invcos(A * B)
 
 		// unit vector it
 		double udist = Math.sqrt( x * x + y * y );
 		double mdist = Math.sqrt( this.x * this.x + this.y * this.y );
 		double tmpx = this.x;
 		double tmpy = this.y;
 
 		//System.out.println( "before    x=" + x    + "    y=" + y    + " udist=" + udist );
 		//System.out.println( "before tmpx=" + tmpx + " tmpy=" + tmpy + " mdist=" + mdist ) ;
 		
 		System.out.print( 
 			" t.x=" + oh( this.x ) + " t.y=" + oh( this.y ) + 
 			" x=" + oh( x ) + " y=" + oh( y ) 
 		);
 		
 		if ( 0 != udist ) {
 			x /= udist;
 			y /= udist;
 		}
 
 		if ( 0 != mdist ) {
 			tmpx /= mdist;
 			tmpy /= mdist;
 		}
 
 		double dot = tmpx * x + tmpy * y;
 		double acos = Math.acos( dot );
 		
 		//System.out.println( "    x=" + x    + "    y=" + y    + " udist=" + udist );
 		//System.out.println( " tmpx=" + tmpx + " tmpy=" + tmpy + " mdist=" + mdist ) ;
 		System.out.println( 
 			" dot=" + oh( dot ) + " acos=" + oh( acos ) 
 		);
 		
 		return acos;
 */
 /***/
 		double angle = 0;
 		
 		double x0 = this.x - x; // a
 		double y0 = this.y - y; // o
 		double dist = Math.sqrt( x0 * x0 + y0 * y0 ); // h
 
 		double bobo = 0;
 		if ( 0 != dist ) {
 			bobo = x0 / dist;
 			angle = Math.acos( x0 / dist );
 			if ( y0 < 0 ) angle = 44.0 / 7.0 - angle;
 		}
 		System.out.println( "" + " x0 = " + x0  + " y0 = " + y0  + " dist = " + dist  + " bobo = " + bobo + " angle = " + angle );
 		return angle;
 /***/
 	}
 
 	/***
 	 *
 	 * Get the angle to a point
 	 *
 	 * @param x coordinate
 	 * @param y coordinate
 	 *
 	 * @return the angle
 	 *
 	 */
 	public double getAngle( Pt2 origin ) {
 		return getAngle( origin.x, origin.y );
 	}
 
    	/***
 	  *
 	  * Set the value
 	  *
 	  * @param newValue to use
 	  *
 	  */
 	public double getX() { return x; }
 
    	/***
 	  *
 	  * Set the value
 	  *
 	  * @param newValue to use
 	  *
 	  */
 	public void setX( double newValue ) { x = newValue; }
 
    	/***
 	  *
 	  * Set the value
 	  *
 	  * @param newValue to use
 	  *
 	  */
 	public double getY() { return y; }
 
    	/***
 	  *
 	  * Set the value
 	  *
 	  * @param newValue to use
 	  *
 	  */
 	public void setY( double newValue ) { y = newValue; }
 
 	/***
 	 *
 	 * Set to the point
 	 *
 	 * @param point to set to
 	 *
 	 * @return this
 	 *
 	 */
 	public Pt2 set( Pt2 point ) {
 		setX( point.getX() );
 		setY( point.getY() );
 		return this;
 	}
 
 	/***
 	 *
 	 * Set to the point
 	 *
 	 * @param point to set to
 	 *
 	 * @return this
 	 *
 	 */
 	public Pt2 set( Point point ) {
 		setX( point.getX() );
 		setY( point.getY() );
 		return this;
 	}
 	
 	/***
 	 *
 	 * Set to the point
 	 *
 	 * @param x coordinate
 	 * @param y coordinate
 	 *
 	 * @return this
 	 *
 	 */
 	public Pt2 set( double x, double y ) {
 		setX( x );
 		setY( y );
 		return this;
 	}
 
 	/***
 	 *
 	 * Convert to a normal vector
 	 *
 	 */
 	public void normalize() {
 		float f = ( float ) Math.sqrt( x * x + y * y );
 		if ( 0 != f ) {
 			x /= f;
 			y /= f;
 		}
 	}
 	
 	// naughty...
 	private double x, y;
 };