/*
 * @(#)Line2D.java	1.18 01/11/29
 *
 * Copyright 2002 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package java.awt.geom;

import java.awt.Shape;
import java.awt.Rectangle;

/**
 * This <code>Line2D</code> represents a line segment in (x, y)
 * coordinate space.  
 * <p>
 * This class is only the abstract superclass for all objects that
 * store a 2D line segment.
 * The actual storage representation of the coordinates is left to
 * the subclass.
 *
 * @version 10 Feb 1997
 * @author	Jim Graham
 */
public abstract class Line2D implements Shape, Cloneable {
    /**
     * A line segment specified with float coordinates.
     */
    public static class Float extends Line2D {
	/**
	 * The X coordinate of the start point of the line segment.
	 */
	public float x1;

	/**
	 * The Y coordinate of the start point of the line segment.
	 */
	public float y1;

	/**
	 * The X coordinate of the end point of the line segment.
	 */
	public float x2;

	/**
	 * The Y coordinate of the end point of the line segment.
	 */
	public float y2;

	/**
	 * Constructs and initializes a Line with coordinates (0, 0) -> (0, 0).
	 */
	public Float() {
	}

	/**
	 * Constructs and initializes a Line from the specified coordinates.
	 * @param X1, Y1 the first specified coordinates
	 * @param X2, Y2 the second specified coordinates
	 */
	public Float(float X1, float Y1, float X2, float Y2) {
	    setLine(X1, Y1, X2, Y2);
	}

	/**
	 * Constructs and initializes a <code>Line2D</code> from the
	 * specified {@link Point2D} objects.
	 * @param p1 the first specified <code>Point2D</code>
	 * @param p2 the second specified <code>Point2D</code>
	 */
	public Float(Point2D p1, Point2D p2) {
	    setLine(p1, p2);
	}

	/**
	 * Returns the X coordinate of the start point in double precision.
	 * @return the x coordinate of this <code>Line2D</code> object's 
	 * 	starting point in double precision. 
	 */
	public double getX1() {
	    return (double) x1;
	} 

	/**
	 * Returns the Y coordinate of the start point in double precision.
         * @return the x coordinate of this <code>Line2D</code> object's 
	 *	starting point in double precision.
	 */
	public double getY1() {
	    return (double) y1;
	}

	/**
	 * Returns the start point.
	 * @return the starting <code>Point2D</code> object of this
	 * 	<code>Line2D</code>.
	 */
	public Point2D getP1() {
	    return new Point2D.Float(x1, y1);
	}

	/**
	 * Returns the X coordinate of the end point in double precision.
         * @return the x coordinate of this <code>Line2D</code> object's 
	 * 	ending point in double precision.	
	 */
	public double getX2() {
	    return (double) x2;
	}

	/**
	 * Returns the Y coordinate of the end point in double precision.
         * @return the Y coordinate of this <code>Line2D</code> object's 
	 *	ending point in double precision.
	 */

	public double getY2() {
	    return (double) y2;
	}

	/**
	 * Returns the end point.
         * @return the ending <code>Point2D</code> object of this
         *      <code>Line2D</code>.
	 */
	public Point2D getP2() {
	    return new Point2D.Float(x2, y2);
	}

	/**
	 * Sets the location of the endpoints of this <code>Line2D</code> 
	 * to the specified double coordinates.
	 * @param X1, Y1 the first specified coordinate
	 * @param X2, Y2 the second specified coordinate
	 */
	public void setLine(double X1, double Y1, double X2, double Y2) {
	    this.x1 = (float) X1;
	    this.y1 = (float) Y1;
	    this.x2 = (float) X2;
	    this.y2 = (float) Y2;
	}

	/**
	 * Sets the location of the endpoints of this <code>Line2D</code> 
	 * to the specified float coordinates.
	 * @param X1, Y1 the first specified coordinate
	 * @param X2, Y2 the second specified coordinate
	 */
	public void setLine(float X1, float Y1, float X2, float Y2) {
	    this.x1 = X1;
	    this.y1 = Y1;
	    this.x2 = X2;
	    this.y2 = Y2;
	}

	/**
	 * Returns the high-precision bounding box of this
	 * <code>Line2D</code>.
	 * @return a {@link Rectangle2D} that is the high-precision
	 * 	bounding box of this <code>Line2D</code>.
	 */
	public Rectangle2D getBounds2D() {
	    float x, y, w, h;
	    if (x1 < x2) {
		x = x1;
		w = x2 - x1;
	    } else {
		x = x2;
		w = x1 - x2;
	    }
	    if (y1 < y2) {
		y = y1;
		h = y2 - y1;
	    } else {
		y = y2;
		h = y1 - y2;
	    }
	    return new Rectangle2D.Float(x, y, w, h);
	}
    }

    /**
     * A line segment specified with double coordinates.
     */
    public static class Double extends Line2D {
	/**
	 * The X coordinate of the start point of the line segment.
	 */
	public double x1;

	/**
	 * The Y coordinate of the start point of the line segment.
	 */
	public double y1;

	/**
	 * The X coordinate of the end point of the line segment.
	 */
	public double x2;

	/**
	 * The Y coordinate of the end point of the line segment.
	 */
	public double y2;

	/**
	 * Constructs and initializes a Line with coordinates (0, 0) -> (0, 0).
	 */
	public Double() {
	}

	/**
	 * Constructs and initializes a <code>Line2D</code> from the
         * specified coordinates.
	 * @param X1, Y1 the first specified coordinate
	 * @param X2, Y2 the second specified coordinate
	 */
	public Double(double X1, double Y1, double X2, double Y2) {
	    setLine(X1, Y1, X2, Y2);
	}

	/**
	 * Constructs and initializes a <code>Line2D</code> from the
	 * specified <code>Point2D</code> objects.
	 * @param p1, p2 the specified <code>Point2D</code> objects
	 */
	public Double(Point2D p1, Point2D p2) {
	    setLine(p1, p2);
	}

	/**
	 * Returns the X coordinate of the start point in double precision.
         * @return the X coordinate of this <code>Line2D</code> object's 
	 * 	starting point.
	 */
	public double getX1() {
	    return x1;
	}

	/**
	 * Returns the Y coordinate of the start point in double precision.
         * @return the X coordinate of this <code>Line2D</code> object's 
	 *	starting point.	
	 */
	public double getY1() {
	    return y1;
	}

	/**
	 * Returns the starting <code>Point2D</code> of this
	 * <code>Line2D</code>.
	 * @return the starting <code>Point2D</code> of this
	 * 	<code>Line2D</code>
	 */
	public Point2D getP1() {
	    return new Point2D.Double(x1, y1);
	}

	/**
	 * Returns the X coordinate of the end point in double precision.
         * @return the X coordinate of this <code>Line2D</code> object's 
	 * 	ending point.
	 */
	public double getX2() {
	    return x2;
	}

	/**
	 * Returns the Y coordinate of the end point in double precision.
         * @return the Y coordinate of this <code>Line2D</code> object's 
	 * 	starting point.	
	 */
	public double getY2() {
	    return y2;
	}

	/**
	 * Returns the end <code>Point2D</code> of this
	 * <code>Line2D</code>.
	 * @return the ending <code>Point2D</code> of this 
	 * 	<code>Line2D</code>.
	 */
	public Point2D getP2() {
	    return new Point2D.Double(x2, y2);
	}

	/**
	 * Sets the location of the endpoints of this <code>Line2D</code> 
	 * to the specified double coordinates.
	 * @param X1, Y1 the first specified coordinate
	 * @param X2, Y2 the second specified coordinate
	 */
	public void setLine(double X1, double Y1, double X2, double Y2) {
	    this.x1 = X1;
	    this.y1 = Y1;
	    this.x2 = X2;
	    this.y2 = Y2;
	}

	/**
	 * Returns the high-precision bounding box of this
	 * <code>Line2D</code>.
	 * @return a <code>Rectangle2D</code> that is the high-precision
	 * 	bounding box of this <code>Line2D</code>.
	 */
	public Rectangle2D getBounds2D() {
	    double x, y, w, h;
	    if (x1 < x2) {
		x = x1;
		w = x2 - x1;
	    } else {
		x = x2;
		w = x1 - x2;
	    }
	    if (y1 < y2) {
		y = y1;
		h = y2 - y1;
	    } else {
		y = y2;
		h = y1 - y2;
	    }
	    return new Rectangle2D.Double(x, y, w, h);
	}
    }

    /**
     * This is an abstract class that cannot be instantiated directly.
     * Type-specific implementation subclasses are available for
     * instantiation and provide a number of formats for storing
     * the information necessary to satisfy the various accessory
     * methods below.
     *
     * @see java.awt.geom.Line2D.Float
     * @see java.awt.geom.Line2D.Double
     */
    protected Line2D() {
    }

    /**
     * Returns the X coordinate of the start point in double precision.
     * @return the X coordinate of this <code>Line2D</code> object's 
     *	    starting point.
     */
    public abstract double getX1();

    /**
     * Returns the Y coordinate of the start point in double precision.
     * @return the Y coordinate of this <code>Line2D</code> object's 
     *	    starting point. 
     */
    public abstract double getY1();

    /**
     * Returns the starting <code>Point2D</code> of this
     * <code>Line2D</code>.
     * @return the starting <code>Point2D</code> of this
     *		<code>Line2D</code>.
     */
    public abstract Point2D getP1();

    /**
     * Returns the X coordinate of the end point in double precision.
     * @return the X coordinate of this <code>Line2D</code> object's 
     *	    starting point.
     */
    public abstract double getX2();

    /**
     * Returns the Y coordinate of the end point in double precision.
     * @return the Y coordinate of this <code>Line2D</code> object's 
     *      starting point.
     */
    public abstract double getY2();

    /**
     * Returns the end <code>Point2D</code> of this <code>Line2D</code>.
     * @return a <code>Point2D</code> that is the endpoint of this
     * 		<code>Line2D</code>.
     */
    public abstract Point2D getP2();

    /**
     * Sets the location of the endpoints of this <code>Line2D</code> to
     * the specified double coordinates.
     * @param X1, Y1 the first specified coordinate
     * @param X2, Y2 the second specified coordinate
     */
    public abstract void setLine(double X1, double Y1, double X2, double Y2);

    /**
     * Sets the location of the endpoints of this <code>Line2D</code> to
     * the specified <code>Point2D</code> coordinates.
     * @param p1, p2 the specified <code>Point2D</code> objects
     */
    public void setLine(Point2D p1, Point2D p2) {
	setLine(p1.getX(), p1.getY(), p2.getX(), p2.getY());
    }

    /**
     * Sets the location of the endpoints of this <code>Line2D</code> to
     * the same as those endpoints of the specified <code>Line2D</code>.
     * @param l the specified <code>Line2D</code>
     */
    public void setLine(Line2D l) {
	setLine(l.getX1(), l.getY1(), l.getX2(), l.getY2());
    }

    /**
     * Returns an indicator of where the specified point 
     * (PX, PY) lies with respect to the line segment from 
     * (X1, Y1) to (X2, Y2).
     * The value is 1 if the line segment must turn counterclockwise
     * to point at the specified point, -1 if it must turn clockwise,
     * or 0 if the point lies exactly on the line segment.
     * If the point is colinear with the line segment, but not between
     * the endpoints, then the value will be -1 if the point lies
     * "beyond (X1, Y1)" or 1 if the point lies 
     * "beyond (X2, Y2)".
     * Note that an indicator value of 0 is rare and not useful for
     * determining colinearity because of floating point rounding
     * issues. 
     * @param X1, Y1 the coordinates of the beginning of the
     *		specified line segment
     * @param X2, Y2 the coordinates of the end of the specified
     *		line segment
     * @param PX, PY the coordinates of the specified point to be
     * 		compared with the specified line segment
     * @return an integer that indicates the position of the third specified
     *			coordinates with respect to the line segment formed
     *			by the first two specified coordinates.
     */
    public static int relativeCCW(double X1, double Y1,
				  double X2, double Y2,
				  double PX, double PY) {
	X2 -= X1;
	Y2 -= Y1;
	PX -= X1;
	PY -= Y1;
	double ccw = PX * Y2 - PY * X2;
	if (ccw == 0.0) {
	    // The point is colinear, classify based on which side of
	    // the segment the point falls on.  We can calculate a
	    // relative value using the projection of PX,PY onto the
	    // segment - a negative value indicates the point projects
	    // outside of the segment in the direction of the particular
	    // endpoint used as the origin for the projection.
	    ccw = PX * X2 + PY * Y2;
	    if (ccw > 0.0) {
		// Reverse the projection to be relative to the original X2,Y2
		// X2 and Y2 are simply negated.
		// PX and PY need to have (X2 - X1) or (Y2 - Y1) subtracted
		//    from them (based on the original values)
		// Since we really want to get a positive answer when the
		//    point is "beyond (X2,Y2)", then we want to calculate
		//    the inverse anyway - thus we leave X2 & Y2 negated.
		PX -= X2;
		PY -= Y2;
		ccw = PX * X2 + PY * Y2;
		if (ccw < 0.0) {
		    ccw = 0.0;
		}
	    }
	}
	return (ccw < 0.0) ? -1 : ((ccw > 0.0) ? 1 : 0);
    }

    /**
     * Returns an indicator of where the specified point 
     * (PX, PY) lies with respect to this line segment.
     * The value is 1 if the line segment must turn counterclockwise
     * to point at the specified point, -1 if it must turn clockwise,
     * or 0 if the point lies exactly on the line segment.
     * If the point is colinear with the line segment, but not between
     * the endpoints, then the value is -1 if the point lies
     * "beyond (x1, y1)" or 1 if the point lies 
     * "beyond (x2, y2)".
     * Note that an indicator value of 0 is rare and not useful for
     * determining colinearity because of floating point rounding
     * issues. 
     * @param PX, PY the coordinates of the specified point
     *			to be compared with the current line segment
     * @return an integer that indicates the position of the specified
     *			coordinates with respect to the current line segment.
     */
    public int relativeCCW(double PX, double PY) {
	return relativeCCW(getX1(), getY1(), getX2(), getY2(), PX, PY);
    }

    /**
     * Returns an indicator of where the specified <code>Point2D</code>
     * lies with respect to this line segment.
     * The value is 1 if the line segment must turn counterclockwise
     * to point at the specified point, -1 if it must turn clockwise,
     * or 0 if the point lies exactly on the line segment.
     * If the point is colinear with the line segment, but not between
     * the endpoints, then the value is -1 if the point lies
     * "beyond (x1, y1)" or 1 if the point lies 
     * "beyond (x2, y2)".
     * Note that an indicator value of 0 is rare and not useful for
     * determining colinearity because of floating point rounding
     * issues. 
     * @param p the specified <code>Point2D</code> to be compared 
     *			with the current line segment
     * @return an integer that indicates the position of the 
     *			<code>Point2D</code> with respect to the current 
     *			line segment.
     */
    public int relativeCCW(Point2D p) {
	return relativeCCW(getX1(), getY1(), getX2(), getY2(),
			   p.getX(), p.getY());
    }

    /**
     * Tests if the line segment from (X1, Y1) to 
     * (X2, Y2) intersects the line segment from (X3, Y3) 
     * to (X4, Y4).
     * @param X1, Y1 the coordinates of the beginning of the first 
     *			specified line segment
     * @param X2, Y2 the coordinates of the end of the first 
     *			specified line segment
     * @param X3, Y3 the coordinates of the beginning of the second
     *			 specified line segment
     * @param X4, Y4 the coordinates of the end of the second 
     *			specified line segment
     * @return <code>true</code> if the first specified line segment 
     *			and the second specified line segment intersect  
     *			each other; <code>false</code> otherwise.  
     */
    public static boolean linesIntersect(double X1, double Y1,
					 double X2, double Y2,
					 double X3, double Y3,
					 double X4, double Y4) {
	return ((relativeCCW(X1, Y1, X2, Y2, X3, Y3) *
		 relativeCCW(X1, Y1, X2, Y2, X4, Y4) <= 0)
		&& (relativeCCW(X3, Y3, X4, Y4, X1, Y1) *
		    relativeCCW(X3, Y3, X4, Y4, X2, Y2) <= 0));
    }

    /**
     * Tests if the line segment from (X1, Y1) to 
     * (X2, Y2) intersects this line segment.
     * @param X1, Y1 the coordinates of the beginning of the 
     *			specified line segment
     * @param X2, Y2 the coordinates of the end of the specified
     *			line segment			
     * @return <true> if this line segment and the specified line segment
     *			intersect each other; <code>false</code> otherwise.
     */
    public boolean intersectsLine(double X1, double Y1, double X2, double Y2) {
	return linesIntersect(X1, Y1, X2, Y2,
			      getX1(), getY1(), getX2(), getY2());
    }

    /**
     * Tests if the specified line segment intersects this line segment.
     * @param l the specified <code>Line2D</code>
     * @return <code>true</code> if this line segment and the specified line
     *			segment intersect each other; 
     *			<code>false</code> otherwise.
     */
    public boolean intersectsLine(Line2D l) {
	return linesIntersect(l.getX1(), l.getY1(), l.getX2(), l.getY2(),
			      getX1(), getY1(), getX2(), getY2());
    }

    /**
     * Returns the square of the distance from a point to a line segment.
     * @param X1, Y1 the coordinates of the beginning of the 
     *			specified line segment
     * @param X2, Y2 the coordinates of the end of the specified 
     *		line segment
     * @param PX, PY the coordinates of the specified point being
     *		measured
     * @return a double value that is the square of the distance from the
     *			specified point to the specified line segment.
     */
    public static double ptSegDistSq(double X1, double Y1,
				     double X2, double Y2,
				     double PX, double PY) {
	// Adjust vectors relative to X1,Y1
	// X2,Y2 becomes relative vector from X1,Y1 to end of segment
	X2 -= X1;
	Y2 -= Y1;
	// PX,PY becomes relative vector from X1,Y1 to test point
	PX -= X1;
	PY -= Y1;
	double dotprod = PX * X2 + PY * Y2;
	double projlenSq;
	if (dotprod <= 0.0) {
	    // PX,PY is on the side of X1,Y1 away from X2,Y2
	    // distance to segment is length of PX,PY vector
	    // "length of its (clipped) projection" is now 0.0
	    projlenSq = 0.0;
	} else {
	    // switch to backwards vectors relative to X2,Y2
	    // X2,Y2 are already the negative of X1,Y1=>X2,Y2
	    // to get PX,PY to be the negative of PX,PY=>X2,Y2
	    // the dot product of two negated vectors is the same
	    // as the dot product of the two normal vectors
	    PX = X2 - PX;
	    PY = Y2 - PY;
	    dotprod = PX * X2 + PY * Y2;
	    if (dotprod <= 0.0) {
		// PX,PY is on the side of X2,Y2 away from X1,Y1
		// distance to segment is length of (backwards) PX,PY vector
		// "length of its (clipped) projection" is now 0.0
		projlenSq = 0.0;
	    } else {
		// PX,PY is between X1,Y1 and X2,Y2
		// dotprod is the length of the PX,PY vector
		// projected on the X2,Y2=>X1,Y1 vector times the
		// length of the X2,Y2=>X1,Y1 vector
		projlenSq = dotprod * dotprod / (X2 * X2 + Y2 * Y2);
	    }
	}
	// Distance to line is now the length of the relative point
	// vector minus the length of its projection onto the line
	// (which is zero if the projection falls outside the range
	//  of the line segment).
	return PX * PX + PY * PY - projlenSq;
    }

    /**
     * Returns the distance from a point to a line segment.
     * @param X1, Y1 the coordinates of the beginning of the
     *		specified line segment
     * @param X2, Y2 the coordinates of the end of the specified line
     * 		segment
     * @param PX, PY the coordinates of the specified point being
     *		measured
     * @return a double value that is the distance from the specified point
     *				to the specified line segment.
     */
    public static double ptSegDist(double X1, double Y1,
				   double X2, double Y2,
				   double PX, double PY) {
	return Math.sqrt(ptSegDistSq(X1, Y1, X2, Y2, PX, PY));
    }

    /**
     * Returns the square of the distance from a point to this line segment.
     * @param PX, PY the coordinates of the specified point being
     * 		measured
     * @return a double value that is the square of the distance from a
     *			specified point to the current line segment.
     */
    public double ptSegDistSq(double PX, double PY) {
	return ptSegDistSq(getX1(), getY1(), getX2(), getY2(), PX, PY);
    }

    /**
     * Returns the square of the distance from a <code>Point2D</code> to 
     * this line segment.
     * @param pt the specified <code>Point2D</code> being measured
     * @return a double value that is the square of the distance from a
     *			specified <code>Point2D</code> to the current 
     *			line segment.
     */
    public double ptSegDistSq(Point2D pt) {
	return ptSegDistSq(getX1(), getY1(), getX2(), getY2(),
			   pt.getX(), pt.getY());
    }

    /**
     * Returns the distance from a point to this line segment.
     * @param PX, PY the coordinates of the specified point
     *				 being measured
     * @return a double value that is the distance from a specified 
     *				point to the current line segment.
     */
    public double ptSegDist(double PX, double PY) {
	return ptSegDist(getX1(), getY1(), getX2(), getY2(), PX, PY);
    }

    /**
     * Returns the distance from a <code>Point2D</code> to this line
     * segment.
     * @param pt the specified <code>Point2D</code> being measured
     * @return a double value that is the distance from a specified
     *				<code>Point2D</code> to the current line
     *				segment.
     */
    public double ptSegDist(Point2D pt) {
	return ptSegDist(getX1(), getY1(), getX2(), getY2(),
			 pt.getX(), pt.getY());
    }

    /**
     * Returns the square of the distance from a point to a line.
     * @param X1, Y1 the coordinates of the beginning of the
     * 		specified line segment
     * @param X2, Y2 the coordinates of the end of the specified 
     *		line segment
     * @param PX, PY the coordinates of the specified point being
     * 		measured
     * @return a double value that is the square of the distance from a
     *			specified point to a specified line segment.
     */
    public static double ptLineDistSq(double X1, double Y1,
				      double X2, double Y2,
				      double PX, double PY) {
	// Adjust vectors relative to X1,Y1
	// X2,Y2 becomes relative vector from X1,Y1 to end of segment
	X2 -= X1;
	Y2 -= Y1;
	// PX,PY becomes relative vector from X1,Y1 to test point
	PX -= X1;
	PY -= Y1;
	double dotprod = PX * X2 + PY * Y2;
	// dotprod is the length of the PX,PY vector
	// projected on the X1,Y1=>X2,Y2 vector times the
	// length of the X1,Y1=>X2,Y2 vector
	double projlenSq = dotprod * dotprod / (X2 * X2 + Y2 * Y2);
	// Distance to line is now the length of the relative point
	// vector minus the length of its projection onto the line
	return PX * PX + PY * PY - projlenSq;
    }

    /**
     * Returns the distance from a point to a line.
     * @param X1, Y1 the coordinates of the beginning of the
     *		specified line segment
     * @param X2, Y2 the coordinates of the end of the specified 
     *		line segment
     * @param PX, PY the coordinates of the specified point being
     *		measured
     * @return a double value that is the distance from a specified
     *			 point to a specified line segment.
     */
    public static double ptLineDist(double X1, double Y1,
				    double X2, double Y2,
				    double PX, double PY) {
	return Math.sqrt(ptLineDistSq(X1, Y1, X2, Y2, PX, PY));
    }

    /**
     * Returns the square of the distance from a point to this line.
     * @param PX, PY the coordinates of the specified point being
     *		measured
     * @return a double value that is the square of the distance from a 
     *			specified point to the current line segment.
     */
    public double ptLineDistSq(double PX, double PY) {
	return ptLineDistSq(getX1(), getY1(), getX2(), getY2(), PX, PY);
    }

    /**
     * Returns the square of the distance from a specified 
     * <code>Point2D</code> to this line.
     * @param pt the specified <code>Point2D</code> being measured
     * @return a double value that is the square of the distance from a
     *			specified <code>Point2D</code> to the current
     *			line segment.
     */
    public double ptLineDistSq(Point2D pt) {
	return ptLineDistSq(getX1(), getY1(), getX2(), getY2(),
			    pt.getX(), pt.getY());
    }

    /**
     * Returns the distance from a point to this line.
     * @param PX, PY the coordinates of the specified point being
     *		measured
     * @return a double value that is the distance from a specified point
     *			to the current line segment.
     */
    public double ptLineDist(double PX, double PY) {
	return ptLineDist(getX1(), getY1(), getX2(), getY2(), PX, PY);
    }

    /**
     * Returns the distance from a <code>Point2D</code> to this line.
     * @param pt the specified <code>Point2D</code> being measured
     * @return a double value that is the distance from a specified 
     *			<code>Point2D</code> to the current line segment.
     */
    public double ptLineDist(Point2D pt) {
	return ptLineDist(getX1(), getY1(), getX2(), getY2(),
			 pt.getX(), pt.getY());
    }

    /**
     * Tests if a specified coordinate is inside the boundary of this
     * <code>Line2D</code>.  This method is required to implement the 
     * {@link Shape} interface, but in the case of <code>Line2D</code> 
     * objects it always returns <code>false</code> since a line contains
     * no area.
     * @param x, y the coordinates of the specified point
     * @return <code>false</code> because a <code>Line2D</code> contains
     * no area.
     */
    public boolean contains(double x, double y) {
	return false;
    }

    /**
     * Tests if a given <code>Point2D</code> is inside the boundary of
     * this <code>Line2D</code>.
     * This method is required to implement the <code>Shape</code> interface, 
     * but in the case of <code>Line2D</code> objects it always returns 
     * <code>false</code> since a line contains no area.
     * @param p the specified <code>Point2D</code> to be tested
     * @return <code>false</code> because a <code>Line2D</code> contains
     * no area.
     */
    public boolean contains(Point2D p) {
	return false;
    }

    /**
     * Tests if this <code>Line2D</code> intersects the interior of a
     * specified set of rectangular coordinates.
     * @param x, y the coordinates of the top-left corner of the
     *		specified rectangular area
     * @param w the width of the specified rectangular area
     * @param h the height of the specified rectangular area
     * @return <code>true</code> if this <code>Line2D</code> intersects 
     *		the interior of the specified set of rectangular
     *		coordinates; <code>false</code> otherwise.	
     */
    public boolean intersects(double x, double y, double w, double h) {
	return intersects(new Rectangle2D.Double(x, y, w, h));
    }

    /**
     * Tests if this <code>Line2D</code> intersects the interior of a
     * specified <code>Rectangle2D</code>.
     * @param r the specified <code>Rectangle2D</code> to be tested
     * @return <code>true</code> if this <code>Line2D</code> intersects
     *		the interior of the specified <code>Rectangle2D</code>
     *		<code>false</code> otherwise.
     */
    public boolean intersects(Rectangle2D r) {
	return r.intersectsLine(getX1(), getY1(), getX2(), getY2());
    }

    /**
     * Tests if the interior of this <code>Line2D</code> entirely contains
     * the specified set of rectangular coordinates.
     * This method is required to implement the <code>Shape</code> interface, 
     * but in the case of <code>Line2D</code> objects it always returns 
     * false since a line contains no area.
     * @param x, y the coordinates of the top-left corner of the
     *		specified rectangular area
     * @param w the width of the specified rectangular area
     * @param h the height of the specified rectangular area
     * @return <code>false</code> because a <code>Line2D</code> contains
     * no area.
     */
    public boolean contains(double x, double y, double w, double h) {
	return false;
    }

    /**
     * Tests if the interior of this <code>Line2D</code> entirely contains
     * the specified <code>Rectangle2D</code>.
     * This method is required to implement the <code>Shape</code> interface, 
     * but in the case of <code>Line2D</code> objects it always returns 
     * <code>false</code> since a line contains no area.
     * @param r the specified <code>Rectangle2D</code> to be tested
     * @return <code>false</code> because a <code>Line2D</code> contains
     * no area.
     */
    public boolean contains(Rectangle2D r) {
	return false;
    }

    /**
     * Returns the bounding box of this <code>Line2D</code>.
     * @return a {@link Rectangle} that is the bounding box of the
     *		<code>Line2D</code>.
     */
    public Rectangle getBounds() {
	return getBounds2D().getBounds();
    }

    /**
     * Returns an iteration object that defines the boundary of this
     * <code>Line2D</code>.
     * The iterator for this class is not multi-threaded safe, 
     * which means that this <code>Line2D</code> class does not 
     * guarantee that modifications to the geometry of this
     * <code>Line2D</code> object do not affect any iterations of that
     * geometry that are already in process.
     * @param at the specified {@link AffineTransform}
     * @return a {@link PathIterator} that defines the boundary of this
     *		<code>Line2D</code>.
     */
    public PathIterator getPathIterator(AffineTransform at) {
	return new LineIterator(this, at);
    }

    /**
     * Returns an iteration object that defines the boundary of this
     * flattened <code>Line2D</code>.
     * The iterator for this class is not multi-threaded safe,
     * which means that this <code>Line2D</code> class does not
     * guarantee that modifications to the geometry of this
     * <code>Line2D</code> object do not affect any iterations of that
     * geometry that are already in process. 
     * @param at the specified <code>AffineTransform</code>
     * @param flatness the maximum amount that the control points for a 
     *		given curve can vary from colinear before a subdivided
     *		curve is replaced by a straight line connecting the
     *		endpoints.  Since a <code>Line2D</code> object is 
     *	        always flat, this parameter is ignored.
     * @return a <code>PathIterator</code> that defines the boundary of the
     *			flattened <code>Line2D</code>
     */
    public PathIterator getPathIterator(AffineTransform at, double flatness) {
	return new LineIterator(this, at);
    }

    /**
     * Creates a new object of the same class as this object.
     *
     * @return     a clone of this instance.
     * @exception  OutOfMemoryError            if there is not enough memory.
     * @see        java.lang.Cloneable
     * @since      JDK1.2
     */
    public Object clone() {
	try {
	    return super.clone();
	} catch (CloneNotSupportedException e) {
	    // this shouldn't happen, since we are Cloneable
	    throw new InternalError();
	}
    }
}