/**
* Determines whether this sector intersects the specified geographic line segment. The line
* segment is specified by a begin location and an end location. The locations are are assumed to
* be connected by a linear path in geographic space. This returns true if any location along that
* linear path intersects this sector, including the begin and end locations.
*
* @param begin the line segment begin location.
* @param end the line segment end location.
* @return true <code>true</code> if this sector intersects the line segment, otherwise <code>
* false</code>.
* @throws IllegalArgumentException if either the begin location or the end location is null.
*/
public boolean intersectsSegment(LatLon begin, LatLon end) {
if (begin == null) {
throw new IllegalArgumentException("Begin Is Null");
}
if (end == null) {
throw new IllegalArgumentException("End Is Null");
}
Vec4 segmentBegin = new Vec4(begin.getLongitude().degrees, begin.getLatitude().degrees, 0);
Vec4 segmentEnd = new Vec4(end.getLongitude().degrees, end.getLatitude().degrees, 0);
Vec4 tmp = segmentEnd.subtract3(segmentBegin);
Vec4 segmentCenter = segmentBegin.add3(segmentEnd).divide3(2);
Vec4 segmentDirection = tmp.normalize3();
double segmentExtent = tmp.getLength3() / 2.0;
LatLon centroid = this.getCentroid();
Vec4 boxCenter = new Vec4(centroid.getLongitude().degrees, centroid.getLatitude().degrees, 0);
double boxExtentX = this.getDeltaLonDegrees() / 2.0;
double boxExtentY = this.getDeltaLatDegrees() / 2.0;
Vec4 diff = segmentCenter.subtract3(boxCenter);
if (Math.abs(diff.x) > (boxExtentX + segmentExtent * Math.abs(segmentDirection.x))) {
return false;
}
if (Math.abs(diff.y) > (boxExtentY + segmentExtent * Math.abs(segmentDirection.y))) {
return false;
}
//noinspection SuspiciousNameCombination
Vec4 segmentPerp = new Vec4(segmentDirection.y, -segmentDirection.x, 0);
return Math.abs(segmentPerp.dot3(diff))
<= (boxExtentX * Math.abs(segmentPerp.x) + boxExtentY * Math.abs(segmentPerp.y));
}
/**
* Compute points on either side of a line segment. This method requires a point on the line, and
* either a next point, previous point, or both.
*
* @param point Center point about which to compute side points.
* @param prev Previous point on the line. May be null if {@code next} is non-null.
* @param next Next point on the line. May be null if {@code prev} is non-null.
* @param leftPositions Left position will be added to this list.
* @param rightPositions Right position will be added to this list.
* @param halfWidth Distance from the center line to the left or right lines.
* @param globe Current globe.
*/
protected void generateParallelPoints(
Vec4 point,
Vec4 prev,
Vec4 next,
List<Position> leftPositions,
List<Position> rightPositions,
double halfWidth,
Globe globe) {
if ((point == null) || (prev == null && next == null)) {
String message = Logging.getMessage("nullValue.PointIsNull");
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
if (leftPositions == null || rightPositions == null) {
String message = Logging.getMessage("nullValue.PositionListIsNull");
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
if (globe == null) {
String message = Logging.getMessage("nullValue.GlobeIsNull");
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
Vec4 offset;
Vec4 normal = globe.computeSurfaceNormalAtPoint(point);
// Compute vector in the direction backward along the line.
Vec4 backward = (prev != null) ? prev.subtract3(point) : point.subtract3(next);
// Compute a vector perpendicular to segment BC, and the globe normal vector.
Vec4 perpendicular = backward.cross3(normal);
double length;
// If both next and previous points are supplied then calculate the angle that bisects the angle
// current, next, prev.
if (next != null && prev != null && !Vec4.areColinear(prev, point, next)) {
// Compute vector in the forward direction.
Vec4 forward = next.subtract3(point);
// Calculate the vector that bisects angle ABC.
offset = forward.normalize3().add3(backward.normalize3());
offset = offset.normalize3();
// Compute the scalar triple product of the vector BC, the normal vector, and the offset
// vector to
// determine if the offset points to the left or the right of the control line.
double tripleProduct = perpendicular.dot3(offset);
if (tripleProduct < 0) {
offset = offset.multiply3(-1);
}
// Determine the length of the offset vector that will keep the left and right lines parallel
// to the control
// line.
Angle theta = backward.angleBetween3(offset);
if (!Angle.ZERO.equals(theta)) length = halfWidth / theta.sin();
else length = halfWidth;
} else {
offset = perpendicular.normalize3();
length = halfWidth;
}
offset = offset.multiply3(length);
// Determine the left and right points by applying the offset.
Vec4 ptRight = point.add3(offset);
Vec4 ptLeft = point.subtract3(offset);
// Convert cartesian points to geographic.
Position posLeft = globe.computePositionFromPoint(ptLeft);
Position posRight = globe.computePositionFromPoint(ptRight);
leftPositions.add(posLeft);
rightPositions.add(posRight);
}