You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1129 lines
40 KiB
1129 lines
40 KiB
/*
|
|
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
package java.awt.geom;
|
|
|
|
import java.awt.Shape;
|
|
import java.awt.Rectangle;
|
|
import java.io.Serializable;
|
|
|
|
/**
|
|
* This <code>Line2D</code> represents a line segment in {@code (x,y)}
|
|
* coordinate space. This class, like all of the Java 2D API, uses a
|
|
* default coordinate system called <i>user space</i> in which the y-axis
|
|
* values increase downward and x-axis values increase to the right. For
|
|
* more information on the user space coordinate system, see the
|
|
* <a href="https://docs.oracle.com/javase/1.3/docs/guide/2d/spec/j2d-intro.fm2.html#61857">
|
|
* Coordinate Systems</a> section of the Java 2D Programmer's Guide.
|
|
* <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.
|
|
*
|
|
* @author Jim Graham
|
|
* @since 1.2
|
|
*/
|
|
public abstract class Line2D implements Shape, Cloneable {
|
|
|
|
/**
|
|
* A line segment specified with float coordinates.
|
|
* @since 1.2
|
|
*/
|
|
public static class Float extends Line2D implements Serializable {
|
|
/**
|
|
* The X coordinate of the start point of the line segment.
|
|
* @since 1.2
|
|
* @serial
|
|
*/
|
|
public float x1;
|
|
|
|
/**
|
|
* The Y coordinate of the start point of the line segment.
|
|
* @since 1.2
|
|
* @serial
|
|
*/
|
|
public float y1;
|
|
|
|
/**
|
|
* The X coordinate of the end point of the line segment.
|
|
* @since 1.2
|
|
* @serial
|
|
*/
|
|
public float x2;
|
|
|
|
/**
|
|
* The Y coordinate of the end point of the line segment.
|
|
* @since 1.2
|
|
* @serial
|
|
*/
|
|
public float y2;
|
|
|
|
/**
|
|
* Constructs and initializes a Line with coordinates (0, 0) → (0, 0).
|
|
* @since 1.2
|
|
*/
|
|
public Float() {
|
|
}
|
|
|
|
/**
|
|
* Constructs and initializes a Line from the specified coordinates.
|
|
* @param x1 the X coordinate of the start point
|
|
* @param y1 the Y coordinate of the start point
|
|
* @param x2 the X coordinate of the end point
|
|
* @param y2 the Y coordinate of the end point
|
|
* @since 1.2
|
|
*/
|
|
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 <code>Point2D</code> objects.
|
|
* @param p1 the start <code>Point2D</code> of this line segment
|
|
* @param p2 the end <code>Point2D</code> of this line segment
|
|
* @since 1.2
|
|
*/
|
|
public Float(Point2D p1, Point2D p2) {
|
|
setLine(p1, p2);
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
public double getX1() {
|
|
return (double) x1;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
public double getY1() {
|
|
return (double) y1;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
public Point2D getP1() {
|
|
return new Point2D.Float(x1, y1);
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
public double getX2() {
|
|
return (double) x2;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
public double getY2() {
|
|
return (double) y2;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
public Point2D getP2() {
|
|
return new Point2D.Float(x2, y2);
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
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 end points of this <code>Line2D</code>
|
|
* to the specified float coordinates.
|
|
* @param x1 the X coordinate of the start point
|
|
* @param y1 the Y coordinate of the start point
|
|
* @param x2 the X coordinate of the end point
|
|
* @param y2 the Y coordinate of the end point
|
|
* @since 1.2
|
|
*/
|
|
public void setLine(float x1, float y1, float x2, float y2) {
|
|
this.x1 = x1;
|
|
this.y1 = y1;
|
|
this.x2 = x2;
|
|
this.y2 = y2;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* JDK 1.6 serialVersionUID
|
|
*/
|
|
private static final long serialVersionUID = 6161772511649436349L;
|
|
}
|
|
|
|
/**
|
|
* A line segment specified with double coordinates.
|
|
* @since 1.2
|
|
*/
|
|
public static class Double extends Line2D implements Serializable {
|
|
/**
|
|
* The X coordinate of the start point of the line segment.
|
|
* @since 1.2
|
|
* @serial
|
|
*/
|
|
public double x1;
|
|
|
|
/**
|
|
* The Y coordinate of the start point of the line segment.
|
|
* @since 1.2
|
|
* @serial
|
|
*/
|
|
public double y1;
|
|
|
|
/**
|
|
* The X coordinate of the end point of the line segment.
|
|
* @since 1.2
|
|
* @serial
|
|
*/
|
|
public double x2;
|
|
|
|
/**
|
|
* The Y coordinate of the end point of the line segment.
|
|
* @since 1.2
|
|
* @serial
|
|
*/
|
|
public double y2;
|
|
|
|
/**
|
|
* Constructs and initializes a Line with coordinates (0, 0) → (0, 0).
|
|
* @since 1.2
|
|
*/
|
|
public Double() {
|
|
}
|
|
|
|
/**
|
|
* Constructs and initializes a <code>Line2D</code> from the
|
|
* specified coordinates.
|
|
* @param x1 the X coordinate of the start point
|
|
* @param y1 the Y coordinate of the start point
|
|
* @param x2 the X coordinate of the end point
|
|
* @param y2 the Y coordinate of the end point
|
|
* @since 1.2
|
|
*/
|
|
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 the start <code>Point2D</code> of this line segment
|
|
* @param p2 the end <code>Point2D</code> of this line segment
|
|
* @since 1.2
|
|
*/
|
|
public Double(Point2D p1, Point2D p2) {
|
|
setLine(p1, p2);
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
public double getX1() {
|
|
return x1;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
public double getY1() {
|
|
return y1;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
public Point2D getP1() {
|
|
return new Point2D.Double(x1, y1);
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
public double getX2() {
|
|
return x2;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
public double getY2() {
|
|
return y2;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
public Point2D getP2() {
|
|
return new Point2D.Double(x2, y2);
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
public void setLine(double x1, double y1, double x2, double y2) {
|
|
this.x1 = x1;
|
|
this.y1 = y1;
|
|
this.x2 = x2;
|
|
this.y2 = y2;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* JDK 1.6 serialVersionUID
|
|
*/
|
|
private static final long serialVersionUID = 7979627399746467499L;
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* @since 1.2
|
|
*/
|
|
protected Line2D() {
|
|
}
|
|
|
|
/**
|
|
* Returns the X coordinate of the start point in double precision.
|
|
* @return the X coordinate of the start point of this
|
|
* {@code Line2D} object.
|
|
* @since 1.2
|
|
*/
|
|
public abstract double getX1();
|
|
|
|
/**
|
|
* Returns the Y coordinate of the start point in double precision.
|
|
* @return the Y coordinate of the start point of this
|
|
* {@code Line2D} object.
|
|
* @since 1.2
|
|
*/
|
|
public abstract double getY1();
|
|
|
|
/**
|
|
* Returns the start <code>Point2D</code> of this <code>Line2D</code>.
|
|
* @return the start <code>Point2D</code> of this <code>Line2D</code>.
|
|
* @since 1.2
|
|
*/
|
|
public abstract Point2D getP1();
|
|
|
|
/**
|
|
* Returns the X coordinate of the end point in double precision.
|
|
* @return the X coordinate of the end point of this
|
|
* {@code Line2D} object.
|
|
* @since 1.2
|
|
*/
|
|
public abstract double getX2();
|
|
|
|
/**
|
|
* Returns the Y coordinate of the end point in double precision.
|
|
* @return the Y coordinate of the end point of this
|
|
* {@code Line2D} object.
|
|
* @since 1.2
|
|
*/
|
|
public abstract double getY2();
|
|
|
|
/**
|
|
* Returns the end <code>Point2D</code> of this <code>Line2D</code>.
|
|
* @return the end <code>Point2D</code> of this <code>Line2D</code>.
|
|
* @since 1.2
|
|
*/
|
|
public abstract Point2D getP2();
|
|
|
|
/**
|
|
* Sets the location of the end points of this <code>Line2D</code> to
|
|
* the specified double coordinates.
|
|
* @param x1 the X coordinate of the start point
|
|
* @param y1 the Y coordinate of the start point
|
|
* @param x2 the X coordinate of the end point
|
|
* @param y2 the Y coordinate of the end point
|
|
* @since 1.2
|
|
*/
|
|
public abstract void setLine(double x1, double y1, double x2, double y2);
|
|
|
|
/**
|
|
* Sets the location of the end points of this <code>Line2D</code> to
|
|
* the specified <code>Point2D</code> coordinates.
|
|
* @param p1 the start <code>Point2D</code> of the line segment
|
|
* @param p2 the end <code>Point2D</code> of the line segment
|
|
* @since 1.2
|
|
*/
|
|
public void setLine(Point2D p1, Point2D p2) {
|
|
setLine(p1.getX(), p1.getY(), p2.getX(), p2.getY());
|
|
}
|
|
|
|
/**
|
|
* Sets the location of the end points of this <code>Line2D</code> to
|
|
* the same as those end points of the specified <code>Line2D</code>.
|
|
* @param l the specified <code>Line2D</code>
|
|
* @since 1.2
|
|
*/
|
|
public void setLine(Line2D l) {
|
|
setLine(l.getX1(), l.getY1(), l.getX2(), l.getY2());
|
|
}
|
|
|
|
/**
|
|
* Returns an indicator of where the specified point
|
|
* {@code (px,py)} lies with respect to the line segment from
|
|
* {@code (x1,y1)} to {@code (x2,y2)}.
|
|
* The return value can be either 1, -1, or 0 and indicates
|
|
* in which direction the specified line must pivot around its
|
|
* first end point, {@code (x1,y1)}, in order to point at the
|
|
* specified point {@code (px,py)}.
|
|
* <p>A return value of 1 indicates that the line segment must
|
|
* turn in the direction that takes the positive X axis towards
|
|
* the negative Y axis. In the default coordinate system used by
|
|
* Java 2D, this direction is counterclockwise.
|
|
* <p>A return value of -1 indicates that the line segment must
|
|
* turn in the direction that takes the positive X axis towards
|
|
* the positive Y axis. In the default coordinate system, this
|
|
* direction is clockwise.
|
|
* <p>A return value of 0 indicates that the point lies
|
|
* exactly on the line segment. Note that an indicator value
|
|
* of 0 is rare and not useful for determining collinearity
|
|
* because of floating point rounding issues.
|
|
* <p>If the point is colinear with the line segment, but
|
|
* not between the end points, then the value will be -1 if the point
|
|
* lies "beyond {@code (x1,y1)}" or 1 if the point lies
|
|
* "beyond {@code (x2,y2)}".
|
|
*
|
|
* @param x1 the X coordinate of the start point of the
|
|
* specified line segment
|
|
* @param y1 the Y coordinate of the start point of the
|
|
* specified line segment
|
|
* @param x2 the X coordinate of the end point of the
|
|
* specified line segment
|
|
* @param y2 the Y coordinate of the end point of the
|
|
* specified line segment
|
|
* @param px the X coordinate of the specified point to be
|
|
* compared with the specified line segment
|
|
* @param py the Y coordinate 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.
|
|
* @since 1.2
|
|
*/
|
|
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
|
|
* {@code (px,py)} lies with respect to this line segment.
|
|
* See the method comments of
|
|
* {@link #relativeCCW(double, double, double, double, double, double)}
|
|
* to interpret the return value.
|
|
* @param px the X coordinate of the specified point
|
|
* to be compared with this <code>Line2D</code>
|
|
* @param py the Y coordinate of the specified point
|
|
* to be compared with this <code>Line2D</code>
|
|
* @return an integer that indicates the position of the specified
|
|
* coordinates with respect to this <code>Line2D</code>
|
|
* @see #relativeCCW(double, double, double, double, double, double)
|
|
* @since 1.2
|
|
*/
|
|
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.
|
|
* See the method comments of
|
|
* {@link #relativeCCW(double, double, double, double, double, double)}
|
|
* to interpret the return value.
|
|
* @param p the specified <code>Point2D</code> to be compared
|
|
* with this <code>Line2D</code>
|
|
* @return an integer that indicates the position of the specified
|
|
* <code>Point2D</code> with respect to this <code>Line2D</code>
|
|
* @see #relativeCCW(double, double, double, double, double, double)
|
|
* @since 1.2
|
|
*/
|
|
public int relativeCCW(Point2D p) {
|
|
return relativeCCW(getX1(), getY1(), getX2(), getY2(),
|
|
p.getX(), p.getY());
|
|
}
|
|
|
|
/**
|
|
* Tests if the line segment from {@code (x1,y1)} to
|
|
* {@code (x2,y2)} intersects the line segment from {@code (x3,y3)}
|
|
* to {@code (x4,y4)}.
|
|
*
|
|
* @param x1 the X coordinate of the start point of the first
|
|
* specified line segment
|
|
* @param y1 the Y coordinate of the start point of the first
|
|
* specified line segment
|
|
* @param x2 the X coordinate of the end point of the first
|
|
* specified line segment
|
|
* @param y2 the Y coordinate of the end point of the first
|
|
* specified line segment
|
|
* @param x3 the X coordinate of the start point of the second
|
|
* specified line segment
|
|
* @param y3 the Y coordinate of the start point of the second
|
|
* specified line segment
|
|
* @param x4 the X coordinate of the end point of the second
|
|
* specified line segment
|
|
* @param y4 the Y coordinate of the end point 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.
|
|
* @since 1.2
|
|
*/
|
|
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 {@code (x1,y1)} to
|
|
* {@code (x2,y2)} intersects this line segment.
|
|
*
|
|
* @param x1 the X coordinate of the start point of the
|
|
* specified line segment
|
|
* @param y1 the Y coordinate of the start point of the
|
|
* specified line segment
|
|
* @param x2 the X coordinate of the end point of the
|
|
* specified line segment
|
|
* @param y2 the Y coordinate of the end point of the
|
|
* specified line segment
|
|
* @return {@code <true>} if this line segment and the specified line segment
|
|
* intersect each other; <code>false</code> otherwise.
|
|
* @since 1.2
|
|
*/
|
|
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.
|
|
* @since 1.2
|
|
*/
|
|
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.
|
|
* The distance measured is the distance between the specified
|
|
* point and the closest point between the specified end points.
|
|
* If the specified point intersects the line segment in between the
|
|
* end points, this method returns 0.0.
|
|
*
|
|
* @param x1 the X coordinate of the start point of the
|
|
* specified line segment
|
|
* @param y1 the Y coordinate of the start point of the
|
|
* specified line segment
|
|
* @param x2 the X coordinate of the end point of the
|
|
* specified line segment
|
|
* @param y2 the Y coordinate of the end point of the
|
|
* specified line segment
|
|
* @param px the X coordinate of the specified point being
|
|
* measured against the specified line segment
|
|
* @param py the Y coordinate of the specified point being
|
|
* measured against the specified line segment
|
|
* @return a double value that is the square of the distance from the
|
|
* specified point to the specified line segment.
|
|
* @see #ptLineDistSq(double, double, double, double, double, double)
|
|
* @since 1.2
|
|
*/
|
|
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).
|
|
double lenSq = px * px + py * py - projlenSq;
|
|
if (lenSq < 0) {
|
|
lenSq = 0;
|
|
}
|
|
return lenSq;
|
|
}
|
|
|
|
/**
|
|
* Returns the distance from a point to a line segment.
|
|
* The distance measured is the distance between the specified
|
|
* point and the closest point between the specified end points.
|
|
* If the specified point intersects the line segment in between the
|
|
* end points, this method returns 0.0.
|
|
*
|
|
* @param x1 the X coordinate of the start point of the
|
|
* specified line segment
|
|
* @param y1 the Y coordinate of the start point of the
|
|
* specified line segment
|
|
* @param x2 the X coordinate of the end point of the
|
|
* specified line segment
|
|
* @param y2 the Y coordinate of the end point of the
|
|
* specified line segment
|
|
* @param px the X coordinate of the specified point being
|
|
* measured against the specified line segment
|
|
* @param py the Y coordinate of the specified point being
|
|
* measured against the specified line segment
|
|
* @return a double value that is the distance from the specified point
|
|
* to the specified line segment.
|
|
* @see #ptLineDist(double, double, double, double, double, double)
|
|
* @since 1.2
|
|
*/
|
|
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.
|
|
* The distance measured is the distance between the specified
|
|
* point and the closest point between the current line's end points.
|
|
* If the specified point intersects the line segment in between the
|
|
* end points, this method returns 0.0.
|
|
*
|
|
* @param px the X coordinate of the specified point being
|
|
* measured against this line segment
|
|
* @param py the Y coordinate of the specified point being
|
|
* measured against this line segment
|
|
* @return a double value that is the square of the distance from the
|
|
* specified point to the current line segment.
|
|
* @see #ptLineDistSq(double, double)
|
|
* @since 1.2
|
|
*/
|
|
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.
|
|
* The distance measured is the distance between the specified
|
|
* point and the closest point between the current line's end points.
|
|
* If the specified point intersects the line segment in between the
|
|
* end points, this method returns 0.0.
|
|
* @param pt the specified <code>Point2D</code> being measured against
|
|
* this line segment.
|
|
* @return a double value that is the square of the distance from the
|
|
* specified <code>Point2D</code> to the current
|
|
* line segment.
|
|
* @see #ptLineDistSq(Point2D)
|
|
* @since 1.2
|
|
*/
|
|
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.
|
|
* The distance measured is the distance between the specified
|
|
* point and the closest point between the current line's end points.
|
|
* If the specified point intersects the line segment in between the
|
|
* end points, this method returns 0.0.
|
|
*
|
|
* @param px the X coordinate of the specified point being
|
|
* measured against this line segment
|
|
* @param py the Y coordinate of the specified point being
|
|
* measured against this line segment
|
|
* @return a double value that is the distance from the specified
|
|
* point to the current line segment.
|
|
* @see #ptLineDist(double, double)
|
|
* @since 1.2
|
|
*/
|
|
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.
|
|
* The distance measured is the distance between the specified
|
|
* point and the closest point between the current line's end points.
|
|
* If the specified point intersects the line segment in between the
|
|
* end points, this method returns 0.0.
|
|
* @param pt the specified <code>Point2D</code> being measured
|
|
* against this line segment
|
|
* @return a double value that is the distance from the specified
|
|
* <code>Point2D</code> to the current line
|
|
* segment.
|
|
* @see #ptLineDist(Point2D)
|
|
* @since 1.2
|
|
*/
|
|
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.
|
|
* The distance measured is the distance between the specified
|
|
* point and the closest point on the infinitely-extended line
|
|
* defined by the specified coordinates. If the specified point
|
|
* intersects the line, this method returns 0.0.
|
|
*
|
|
* @param x1 the X coordinate of the start point of the specified line
|
|
* @param y1 the Y coordinate of the start point of the specified line
|
|
* @param x2 the X coordinate of the end point of the specified line
|
|
* @param y2 the Y coordinate of the end point of the specified line
|
|
* @param px the X coordinate of the specified point being
|
|
* measured against the specified line
|
|
* @param py the Y coordinate of the specified point being
|
|
* measured against the specified line
|
|
* @return a double value that is the square of the distance from the
|
|
* specified point to the specified line.
|
|
* @see #ptSegDistSq(double, double, double, double, double, double)
|
|
* @since 1.2
|
|
*/
|
|
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
|
|
double lenSq = px * px + py * py - projlenSq;
|
|
if (lenSq < 0) {
|
|
lenSq = 0;
|
|
}
|
|
return lenSq;
|
|
}
|
|
|
|
/**
|
|
* Returns the distance from a point to a line.
|
|
* The distance measured is the distance between the specified
|
|
* point and the closest point on the infinitely-extended line
|
|
* defined by the specified coordinates. If the specified point
|
|
* intersects the line, this method returns 0.0.
|
|
*
|
|
* @param x1 the X coordinate of the start point of the specified line
|
|
* @param y1 the Y coordinate of the start point of the specified line
|
|
* @param x2 the X coordinate of the end point of the specified line
|
|
* @param y2 the Y coordinate of the end point of the specified line
|
|
* @param px the X coordinate of the specified point being
|
|
* measured against the specified line
|
|
* @param py the Y coordinate of the specified point being
|
|
* measured against the specified line
|
|
* @return a double value that is the distance from the specified
|
|
* point to the specified line.
|
|
* @see #ptSegDist(double, double, double, double, double, double)
|
|
* @since 1.2
|
|
*/
|
|
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.
|
|
* The distance measured is the distance between the specified
|
|
* point and the closest point on the infinitely-extended line
|
|
* defined by this <code>Line2D</code>. If the specified point
|
|
* intersects the line, this method returns 0.0.
|
|
*
|
|
* @param px the X coordinate of the specified point being
|
|
* measured against this line
|
|
* @param py the Y coordinate of the specified point being
|
|
* measured against this line
|
|
* @return a double value that is the square of the distance from a
|
|
* specified point to the current line.
|
|
* @see #ptSegDistSq(double, double)
|
|
* @since 1.2
|
|
*/
|
|
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.
|
|
* The distance measured is the distance between the specified
|
|
* point and the closest point on the infinitely-extended line
|
|
* defined by this <code>Line2D</code>. If the specified point
|
|
* intersects the line, this method returns 0.0.
|
|
* @param pt the specified <code>Point2D</code> being measured
|
|
* against this line
|
|
* @return a double value that is the square of the distance from a
|
|
* specified <code>Point2D</code> to the current
|
|
* line.
|
|
* @see #ptSegDistSq(Point2D)
|
|
* @since 1.2
|
|
*/
|
|
public double ptLineDistSq(Point2D pt) {
|
|
return ptLineDistSq(getX1(), getY1(), getX2(), getY2(),
|
|
pt.getX(), pt.getY());
|
|
}
|
|
|
|
/**
|
|
* Returns the distance from a point to this line.
|
|
* The distance measured is the distance between the specified
|
|
* point and the closest point on the infinitely-extended line
|
|
* defined by this <code>Line2D</code>. If the specified point
|
|
* intersects the line, this method returns 0.0.
|
|
*
|
|
* @param px the X coordinate of the specified point being
|
|
* measured against this line
|
|
* @param py the Y coordinate of the specified point being
|
|
* measured against this line
|
|
* @return a double value that is the distance from a specified point
|
|
* to the current line.
|
|
* @see #ptSegDist(double, double)
|
|
* @since 1.2
|
|
*/
|
|
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.
|
|
* The distance measured is the distance between the specified
|
|
* point and the closest point on the infinitely-extended line
|
|
* defined by this <code>Line2D</code>. If the specified point
|
|
* intersects the line, this method returns 0.0.
|
|
* @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.
|
|
* @see #ptSegDist(Point2D)
|
|
* @since 1.2
|
|
*/
|
|
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 the X coordinate of the specified point to be tested
|
|
* @param y the Y coordinate of the specified point to be tested
|
|
* @return <code>false</code> because a <code>Line2D</code> contains
|
|
* no area.
|
|
* @since 1.2
|
|
*/
|
|
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 {@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 p the specified <code>Point2D</code> to be tested
|
|
* @return <code>false</code> because a <code>Line2D</code> contains
|
|
* no area.
|
|
* @since 1.2
|
|
*/
|
|
public boolean contains(Point2D p) {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
public boolean intersects(double x, double y, double w, double h) {
|
|
return intersects(new Rectangle2D.Double(x, y, w, h));
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
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 the X coordinate of the upper-left corner of the
|
|
* specified rectangular area
|
|
* @param y the Y coordinate of the upper-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.
|
|
* @since 1.2
|
|
*/
|
|
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.
|
|
* @since 1.2
|
|
*/
|
|
public boolean contains(Rectangle2D r) {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @since 1.2
|
|
*/
|
|
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>.
|
|
* @since 1.2
|
|
*/
|
|
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
|
|
* end points. 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>
|
|
* @since 1.2
|
|
*/
|
|
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 1.2
|
|
*/
|
|
public Object clone() {
|
|
try {
|
|
return super.clone();
|
|
} catch (CloneNotSupportedException e) {
|
|
// this shouldn't happen, since we are Cloneable
|
|
throw new InternalError(e);
|
|
}
|
|
}
|
|
}
|