/***********************************************************************

 * mt4j Copyright (c) 2008 - 2009 C.Ruff, Fraunhofer-Gesellschaft All rights reserved.

 *  

 *   This program is free software: you can redistribute it and/or modify

 *   it under the terms of the GNU General Public License as published by

 *   the Free Software Foundation, either version 3 of the License, or

 *   (at your option) any later version.

 *

 *   This program 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 General Public License for more details.

 *

 *   You should have received a copy of the GNU General Public License

 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.

 *

 ***********************************************************************/

package org.mt4j.util.math;



/**

 * The Class Plane.

 */

public class Plane {



	 /** The Constant XY. */

 	public static final Plane XY = new Plane(new Vector3D(), Vector3D.Z_AXIS);

     

     /** The Constant XZ. */

     public static final Plane XZ = new Plane(new Vector3D(), Vector3D.Y_AXIS);

     

     /** The Constant YZ. */

     public static final Plane YZ = new Plane(new Vector3D(), Vector3D.X_AXIS);



     public static final int PLANE_FRONT = -1;



     public static final int PLANE_BACK = 1;



     public static final int ON_PLANE = 0;



     /** The Normal of the plane. */

     public Vector3D normal;

     

     /** The origin of the plane (a point in the plane). */

     public Vector3D origin;



     /**

      * The Constructor.

      * 

      * @param origin the origin

      * @param norm the norm

      */

     public Plane(Vector3D origin, Vector3D norm) {

    	 this.origin = origin;

         this.normal = norm.getNormalized();

     }

     

     /**

      * The Constructor.

      * 

      * @param v0 the v0

      * @param v1 the v1

      * @param v2 the v2

      */

     public Plane(Vector3D v0, Vector3D v1, Vector3D v2) {

    	 this.normal = ToolsGeometry.getNormal(v0, v1, v2, true);

    	 this.origin = v0;

     }



     public void reconstruct(Vector3D v0, Vector3D v1, Vector3D v2) {

    	 this.normal = ToolsGeometry.getNormal(v0, v1, v2, true);

    	 this.origin = v0;

     }

     

     public void reconstruct(Vector3D origin, Vector3D norm) {

    	 this.origin = origin;

         this.normal = norm.getNormalized();

     }

     

//TODO transform methods?

     

     /**

      * Calculates distance from the plane to point P.

      * 

      * @param p the p

      * 

      * @return distance

      */

     public float getDistanceToPoint(Vector3D p) {

    	 float sn = - normal.dot(p.getSubtracted(this.origin));

    	 float sd = normal.lengthSquared();

    	 Vector3D isec = p.getAdded(normal.getScaled(sn / sd));

    	 return Vector3D.distance(isec, p);

     }



     /**

      * Calculates the intersection point between plane and ray (line).

      * 

      * @param r the r

      * 

      * @return intersection point or null if ray doesn't intersect plane

      */

     public Vector3D getIntersectionLocal(Ray r) {

//             float denom = normal.dot(r.getRayDirectionNormalized());

//             if (denom > FastMath.FLT_EPSILON) {

//                     float u = normal.dot(this.origin.getSubtracted(r.getRayStartPoint())) / denom;

//                     Vector3D p =  r.getRayStartPoint().getAdded(r.getRayDirectionNormalized().getScaled(u));  

//                     return p;

//             } else

//                     return null;

             return ToolsGeometry.getRayPlaneIntersection(r, this.normal, this.origin);

     }



     /**

      * Classifies the relative position of the given point to the plane.

      * 

      * @param p the p

      * 

      * @return One of the 3 integer classification codes: PLANE_FRONT, PLANE_BACK, ON_PLANE

      */

     public int classifyPoint(Vector3D p) {

             float d = this.origin.getSubtracted(p).dot(normal);

             if (d < - ToolsMath.FLT_EPSILON)

                     return PLANE_FRONT;

             else if (d > ToolsMath.FLT_EPSILON)

                     return PLANE_BACK;

             return ON_PLANE;

     }

     

     /**

      * Component contains point local.

      * 

      * @param testPoint the test point

      * 

      * @return true, if successful

      */

     public boolean componentContainsPointLocal(Vector3D testPoint) {

    	 return this.classifyPoint(testPoint) == ON_PLANE;

     }



     

     /* (non-Javadoc)

     * @see java.lang.Object#toString()

     */

    public String toString() {

             StringBuffer sb = new StringBuffer();

             sb.append("origin: ").append(super.toString()).append(" norm: ").append(normal.toString());

             return sb.toString();

     }



	

}