/* File Hyperbola2D.java 
    *
    * Project : Java Geometry Library
    *
    * ===========================================
    * 
    * This library is free software; you can redistribute it and/or modify it 
    * under the terms of the GNU Lesser General Public License as published by
    * the Free Software Foundation, either version 2.1 of the License, or (at
   * your option) any later version.
   *
   * This library is distributed in the hope that it will be useful, but 
   * WITHOUT ANY WARRANTY, without even the implied warranty of MERCHANTABILITY
   * or FITNESS FOR A PARTICULAR PURPOSE.
   *
   * See the GNU Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public License
   * along with this library. if not, write to :
   * The Free Software Foundation, Inc., 59 Temple Place, Suite 330,
   * Boston, MA 02111-1307, USA.
   */
  
  // package
  
  package math.geom2d.conic;
  
  import java.awt.Graphics2D;
  import java.util.ArrayList;
  import java.util.Collection;
  
  import math.geom2d.AffineTransform2D;
  import math.geom2d.Angle2D;
  import math.geom2d.Point2D;
  import math.geom2d.Shape2D;
  import math.geom2d.UnboundedShapeException;
  import math.geom2d.Vector2D;
  import math.geom2d.domain.BoundarySet2D;
  import math.geom2d.line.LinearShape2D;
  import math.geom2d.line.StraightLine2D;
  
  // Imports
  
  /**
   * An Hyperbola, which is represented as a curve set of two boundary curves
   * which are instances of HyperbolaBranch2D.
   */
  public class Hyperbola2D extends BoundarySet2D<HyperbolaBranch2D> 
  implements Conic2D, Cloneable {
  
      // ===================================================================
      // constants
  
      // ===================================================================
      // class variables
  
      /** Center of the hyperbola */
      protected double            xc      = 0;
      protected double            yc      = 0;
  
      /** first focal parameter */
      protected double            a       = 1;
  
      /** second focal parameter */
      protected double            b       = 1;
  
      /** angle of rotation of the hyperbola */
      protected double            theta   = 0;
  
      /** a flag indicating whether the hyperbola is direct or not */
      protected boolean           direct  = true;
  
      /** The negative branch of the hyperbola */
      protected HyperbolaBranch2D branch1 = null;
      
      /** The positive branch of the hyperbola */
      protected HyperbolaBranch2D branch2 = null;
  
      // ===================================================================
      // constructors
  
      /**
       * Assume centered hyperbola, with a = b = 1 (orthogonal hyperbola), theta=0
       * (hyperbola is oriented East-West), and direct orientation.
       */
      public Hyperbola2D() {
          this(0, 0, 1, 1, 0, true);
      }
  
      public Hyperbola2D(Point2D center, double a, double b, double theta) {
          this(center.getX(), center.getY(), a, b, theta, true);
      }
  
      public Hyperbola2D(Point2D center, double a, double b, double theta,
              boolean d) {
          this(center.getX(), center.getY(), a, b, theta, d);
      }
  
      public Hyperbola2D(double xc, double yc, double a, double b, double theta) {
         this(xc, yc, a, b, theta, true);
     }
 
     /** Main constructor */
     public Hyperbola2D(double xc, double yc, double a, double b, double theta,
             boolean d) {
         this.xc = xc;
         this.yc = yc;
         this.a = a;
         this.b = b;
         this.theta = theta;
         this.direct = d;
 
         branch1 = new HyperbolaBranch2D(this, false);
         branch2 = new HyperbolaBranch2D(this, true);
         this.addCurve(branch1);
         this.addCurve(branch2);
     }
 
     
     // ===================================================================
     // Static factories
     
     public static Hyperbola2D create(Point2D center, double a, double b,
     		double theta) {
         return new Hyperbola2D(center.getX(), center.getY(), a, b, theta, true);
     }
 
     public static Hyperbola2D create(Point2D center, double a, double b,
     		double theta, boolean d) {
     	return new Hyperbola2D(center.getX(), center.getY(), a, b, theta, d);
     }
 
     
     // ===================================================================
     // static methods
 
     /**
      * Creates a new Hyperbola by reducing the conic coefficients, assuming
      * conic type is Hyperbola, and hyperbola is centered.
      * 
      * @param coefs an array of double with at least 3 coefficients containing
      *            coefficients for x^2, xy, and y^2 factors. If the array is
      *            longer, remaining coefficients are ignored.
      * @return the Hyperbola2D corresponding to given coefficients
      */
     public static Hyperbola2D reduceCentered(double[] coefs) {
         double A = coefs[0];
         double B = coefs[1];
         double C = coefs[2];
 
         // Compute orientation angle of the hyperbola
         double theta;
         if (Math.abs(A-C)<Shape2D.ACCURACY) {
             theta = Math.PI/4;
         } else {
             theta = Math.atan2(B, (A-C))/2.0;
             if (B<0)
                 theta -= Math.PI;
             theta = Angle2D.formatAngle(theta);
         }
 
         // compute ellipse in isothetic basis
         double[] coefs2 = Conic2DUtils.transformCentered(coefs,
                 AffineTransform2D.createRotation(-theta));
 
         // extract coefficient f if present
         double f = 1;
         if (coefs2.length>5)
             f = Math.abs(coefs[5]);
 
         assert Math.abs(coefs2[1]/f)<Shape2D.ACCURACY :
         	"Second conic coefficient should be zero";
 
         assert coefs2[0]*coefs2[2]<0:
             "Transformed conic is not an Hyperbola";
         
 
         // extract major and minor axis lengths, ensuring r1 is greater
         double r1, r2;
         if (coefs2[0]>0) {
             // East-West hyperbola
             r1 = Math.sqrt(f/coefs2[0]);
             r2 = Math.sqrt(-f/coefs2[2]);
         } else {
             // North-South hyperbola
             r1 = Math.sqrt(f/coefs2[2]);
             r2 = Math.sqrt(-f/coefs2[0]);
             theta = Angle2D.formatAngle(theta+Math.PI/2);
             theta = Math.min(theta, Angle2D.formatAngle(theta+Math.PI));
         }
 
         // Return the new Hyperbola
         return new Hyperbola2D(0, 0, r1, r2, theta, true);
     }
 
     /**
      * Transforms an hyperbola, by supposing both the hyperbola is centered
      * and the transform has no translation part.
      * 
      * @param hyper an hyperbola
      * @param trans an affine transform
      * @return the transformed hyperbola, centered around origin
      */
     public static Hyperbola2D transformCentered(Hyperbola2D hyper,
             AffineTransform2D trans) {
         // Extract inner parameter of hyperbola
         double a = hyper.a;
         double b = hyper.b;
         double theta = hyper.theta;
 
         // precompute some parts
         double aSq = a*a;
         double bSq = b*b;
         double cot = Math.cos(theta);
         double sit = Math.sin(theta);
         double cotSq = cot*cot;
         double sitSq = sit*sit;
 
         // compute coefficients of the centered conic
         double A = cotSq/aSq-sitSq/bSq;
         double B = 2*cot*sit*(1/aSq+1/bSq);
         double C = sitSq/aSq-cotSq/bSq;
         double[] coefs = new double[] { A, B, C };
 
         // Compute coefficients of the transformed conic, still centered
         double[] coefs2 = Conic2DUtils.transformCentered(coefs, trans);
 
         // reduce conic coefficients to an hyperbola
         return Hyperbola2D.reduceCentered(coefs2);
     }
 
 
     // ===================================================================
     // methods specific to Hyperbola2D
 
     /**
      * transform a point in local coordinate (ie orthogonal centered hyberbola
      * with a=b=1) to global coordinate system.
      */
     public Point2D toGlobal(Point2D point) {
         point = point.transform(AffineTransform2D.createScaling(a, b));
         point = point.transform(AffineTransform2D.createRotation(theta));
         point = point.transform(AffineTransform2D.createTranslation(xc, yc));
         return point;
     }
 
     public Point2D toLocal(Point2D point) {
         point = point.transform(AffineTransform2D.createTranslation(-xc, -yc));
         point = point.transform(AffineTransform2D.createRotation(-theta));
         point = point.transform(AffineTransform2D.createScaling(1/a, 1/b));
         return point;
     }
 
     /**
      * Change coordinate of the line to correspond to a standard hyperbola.
      * Standard hyperbola is such that x^2-y^2=1 for every point.
      * 
      * @param point
      * @return
      */
     private LinearShape2D formatLine(LinearShape2D line) {
         line = line.transform(AffineTransform2D.createTranslation(-xc, -yc));
         line = line.transform(AffineTransform2D.createRotation(-theta));
         line = line.transform(AffineTransform2D.createScaling(1.0/a, 1.0/b));
         return line;
     }
 
     /**
      * Returns the center of the Hyperbola. This point does not belong to the
      * Hyperbola.
      * @return the center point of the Hyperbola.
      */
     public Point2D getCenter() {
         return new Point2D(xc, yc);
     }
 
     /** 
      * Returns the angle made by the first direction vector with the horizontal
      * axis.
      */
     public double getAngle() {
         return theta;
     }
 
     /** Returns a */
     public double getLength1() {
         return a;
     }
 
     /** Returns b */
     public double getLength2() {
         return b;
     }
 
     public boolean isDirect() {
         return direct;
     }
 
     public Vector2D getVector1() {
         return new Vector2D(Math.cos(theta), Math.sin(theta));
     }
 
     public Vector2D getVector2() {
         return new Vector2D(-Math.sin(theta), Math.cos(theta));
     }
 
     /**
      * Returns the focus located on the positive side of the main hyperbola
      * axis.
      */
     public Point2D getFocus1() {
         double c = Math.hypot(a, b);
         return new Point2D(xc+c*Math.cos(theta), yc+c*Math.sin(theta));
     }
 
     /**
      * Returns the focus located on the negative side of the main hyperbola
      * axis.
      */
     public Point2D getFocus2() {
         double c = Math.hypot(a, b);
         return new Point2D(xc-c*Math.cos(theta), yc-c*Math.sin(theta));
     }
     
     public HyperbolaBranch2D getPositiveBranch() {
     	return branch2;
     }
 
     public HyperbolaBranch2D getNegativeBranch() {
     	return branch1;
     }
     
     public Collection<HyperbolaBranch2D> getBranches() {
     	ArrayList<HyperbolaBranch2D> array = 
     		new ArrayList<HyperbolaBranch2D>(2);
     	array.add(branch1);
     	array.add(branch2);
     	return array;
     }
     
     /**
      * Returns the asymptotes of the hyperbola.
      */
     public Collection<StraightLine2D> getAsymptotes() {    	
     	// Compute base direction vectors
     	Vector2D v1 = new Vector2D(a, b);
     	Vector2D v2 = new Vector2D(a, -b);
     	
     	// rotate by the angle of the hyperbola with Ox axis
     	AffineTransform2D rot = AffineTransform2D.createRotation(this.theta);
     	v1 = v1.transform(rot);
     	v2 = v2.transform(rot);
 
     	// init array for storing lines
     	ArrayList<StraightLine2D> array = new ArrayList<StraightLine2D>(2);
     	
     	// add each asymptote
     	Point2D center = this.getCenter();
     	array.add(new StraightLine2D(center, v1));
     	array.add(new StraightLine2D(center, v2));
     	
     	// return the array of asymptotes
     	return array;
     }
 
     // ===================================================================
     // methods inherited from Conic2D interface
 
     public double[] getConicCoefficients() {
         // scaling coefficients
         double aSq = this.a*this.a;
         double bSq = this.b*this.b;
         double aSqInv = 1.0/aSq;
         double bSqInv = 1.0/bSq;
 
         // angle of hyperbola with horizontal, and trigonometric formulas
         double sint = Math.sin(this.theta);
         double cost = Math.cos(this.theta);
         double sin2t = 2.0*sint*cost;
         double sintSq = sint*sint;
         double costSq = cost*cost;
 
         // coefs from hyperbola center
         double xcSq = xc*xc;
         double ycSq = yc*yc;
 
         /*
          * Compute the coefficients. These formulae are the transformations on
          * the unit hyperbola written out long hand
          */
 
         double a = costSq/aSq-sintSq/bSq;
         double b = (bSq+aSq)*sin2t/(aSq*bSq);
         double c = sintSq/aSq-costSq/bSq;
         double d = -yc*b-2*xc*a;
         double e = -xc*b-2*yc*c;
         double f = -1.0+(xcSq+ycSq)*(aSqInv-bSqInv)/2.0+(costSq-sintSq)
                 *(xcSq-ycSq)*(aSqInv+bSqInv)/2.0+xc*yc*(aSqInv+bSqInv)*sin2t;
         // Equivalent to:
         // double f = (xcSq*costSq + xc*yc*sin2t + ycSq*sintSq)*aSqInv
         // - (xcSq*sintSq - xc*yc*sin2t + ycSq*costSq)*bSqInv - 1;
 
         // Return array of results
         return new double[] { a, b, c, d, e, f };
     }
 
     public Conic2D.Type getConicType() {
         return Conic2D.Type.HYPERBOLA;
     }
 
     public double getEccentricity() {
         return Math.hypot(1, b*b/a/a);
     }
 
     
     // ===================================================================
     // methods implementing the Curve2D interface
 
     @Override
     public Hyperbola2D getReverseCurve() {
         return new Hyperbola2D(this.xc, this.yc, this.a, this.b, this.theta,
                 !this.direct);
     }
 
     @Override
     public Collection<Point2D> getIntersections(LinearShape2D line) {
 
         Collection<Point2D> points = new ArrayList<Point2D>();
 
         // format to 'standard' hyperbola
         LinearShape2D line2 = formatLine(line);
 
         // Extract formatted line parameters
         Point2D origin = line2.getOrigin();
         double dx = line2.getVector().getX();
         double dy = line2.getVector().getY();
 
         // extract line parameters
         // different strategy depending if line is more horizontal or more
         // vertical
         if (Math.abs(dx)>Math.abs(dy)) {
             // Line is mainly horizontal
 
             // slope and intercept of the line: y(x) = k*x + yi
             double k = dy/dx;
             double yi = origin.getY()-k*origin.getX();
 
             // compute coefficients of second order equation
             double a = 1-k*k;
             double b = -2*k*yi;
             double c = -yi*yi-1;
 
             double delta = b*b-4*a*c;
             if (delta<=0) {
                 System.out.println(
                         "Intersection with horizontal line should alays give positive delta");
                 return points;
             }
 
             // x coordinate of intersection points
             double x1 = (-b-Math.sqrt(delta))/(2*a);
             double x2 = (-b+Math.sqrt(delta))/(2*a);
 
             // support line of formatted line
             StraightLine2D support = line2.getSupportingLine();
 
             // check first point is on the line
             double pos1 = support.project(new Point2D(x1, k*x1+yi));
             if (line2.contains(support.getPoint(pos1)))
                 points.add(line.getPoint(pos1));
 
             // check second point is on the line
             double pos2 = support.project(new Point2D(x2, k*x2+yi));
             if (line2.contains(support.getPoint(pos2)))
                 points.add(line.getPoint(pos2));
 
         } else {
             // Line is mainly vertical
 
             // slope and intercept of the line: x(y) = k*y + xi
             double k = dx/dy;
             double xi = origin.getX()-k*origin.getY();
 
             // compute coefficients of second order equation
             double a = k*k-1;
             double b = 2*k*xi;
             double c = xi*xi-1;
 
             double delta = b*b-4*a*c;
             if (delta<=0) {
                 // No intersection with the hyperbola
                 return points;
             }
 
             // x coordinate of intersection points
             double y1 = (-b-Math.sqrt(delta))/(2*a);
             double y2 = (-b+Math.sqrt(delta))/(2*a);
 
             // support line of formatted line
             StraightLine2D support = line2.getSupportingLine();
 
             // check first point is on the line
             double pos1 = support.project(new Point2D(k*y1+xi, y1));
             if (line2.contains(support.getPoint(pos1)))
                 points.add(line.getPoint(pos1));
 
             // check second point is on the line
             double pos2 = support.project(new Point2D(k*y2+xi, y2));
             if (line2.contains(support.getPoint(pos2)))
                 points.add(line.getPoint(pos2));
         }
 
         return points;
     }
 
     // ===================================================================
     // methods implementing the Shape2D interface
 
     @Override
     public boolean contains(java.awt.geom.Point2D point) {
         return this.contains(point.getX(), point.getY());
     }
 
     @Override
     public boolean contains(double x, double y) {
         Point2D point = toLocal(new Point2D(x, y));
         double xa = point.getX()/a;
         double yb = point.getY()/b;
         double res = xa*xa-yb*yb-1;
         // double res = x*x*b*b - y*y*a*a - a*a*b*b;
         return Math.abs(res)<1e-6;
     }
 
     /**
      * Transforms this Hyperbola by an affine transform.
      */
     @Override
     public Hyperbola2D transform(AffineTransform2D trans) {
         Hyperbola2D result = Hyperbola2D.transformCentered(this, trans);
         Point2D center = this.getCenter().transform(trans);
         result.xc = center.getX();
         result.yc = center.getY();
         //TODO: check convention for transform with indirect transform, see Curve2D.
         result.direct = this.direct^!trans.isDirect();
         return result;
     }
 
     /** Throws an UnboundedShapeException */
     @Override
     public void draw(Graphics2D g) {
         throw new UnboundedShapeException(this);
     }
 
     /**
      * Tests whether this hyperbola equals another object.
      */
     @Override
     public boolean equals(Object obj) {
         if (!(obj instanceof Hyperbola2D))
             return false;
 
         // Cast to hyperbola
         Hyperbola2D that = (Hyperbola2D) obj;
 
         // check if each parameter is the same
         double eps = 1e-6;
         if (Math.abs(that.xc-this.xc)>eps)
             return false;
         if (Math.abs(that.yc-this.yc)>eps)
             return false;
         if (Math.abs(that.a-this.a)>eps)
             return false;
         if (Math.abs(that.b-this.b)>eps)
             return false;
         if (Math.abs(that.theta-this.theta)>eps)
             return false;
         if (this.direct!=that.direct)
             return false;
 
         // same parameters, then same parabola
         return true;
     }
 
     @Override
     public Hyperbola2D clone() {
         return new Hyperbola2D(xc, yc, a, b, theta, direct);
     }
 }