/**
* Performs one line of sight calculation between the reference position and a specified grid
* position.
*
* @param gridPosition the grid position.
* @throws InterruptedException if the operation is interrupted.
*/
protected void performIntersection(Position gridPosition) throws InterruptedException {
// Intersect the line between this grid point and the selected position.
Intersection[] intersections = this.terrain.intersect(this.referencePosition, gridPosition);
if (intersections == null || intersections.length == 0) {
// No intersection, so the line goes from the center to the grid point.
this.sightLines.add(new Position[] {this.referencePosition, gridPosition});
return;
}
// Only the first intersection is shown.
Vec4 iPoint = intersections[0].getIntersectionPoint();
Vec4 gPoint =
terrain.getSurfacePoint(
gridPosition.getLatitude(), gridPosition.getLongitude(), gridPosition.getAltitude());
// Check to see whether the intersection is beyond the grid point.
if (iPoint.distanceTo3(this.referencePoint) >= gPoint.distanceTo3(this.referencePoint)) {
// Intersection is beyond the grid point; the line goes from the center to the grid point.
this.addSightLine(this.referencePosition, gridPosition);
return;
}
// Compute the position corresponding to the intersection.
Position iPosition = this.terrain.getGlobe().computePositionFromPoint(iPoint);
// The sight line goes from the user-selected position to the intersection position.
this.addSightLine(this.referencePosition, new Position(iPosition, 0));
// Keep track of the intersection positions.
this.addIntersectionPosition(iPosition);
this.updateProgress();
}
protected boolean areShapesIntersecting(Airspace a1, Airspace a2) {
if ((a1 instanceof SphereAirspace) && (a2 instanceof SphereAirspace)) {
SphereAirspace s1 = (SphereAirspace) a1;
SphereAirspace s2 = (SphereAirspace) a2;
LatLon location1 = s1.getLocation();
LatLon location2 = s2.getLocation();
double altitude1 = s1.getAltitudes()[0];
double altitude2 = s2.getAltitudes()[0];
boolean terrainConforming1 = s1.isTerrainConforming()[0];
boolean terrainConforming2 = s2.isTerrainConforming()[0];
// We have to compute the 3D coordinates of the sphere's center ourselves here.
Vec4 p1 =
terrainConforming1
? this.getSurfacePoint(location1, altitude1)
: this.getPoint(location1, altitude1);
Vec4 p2 =
terrainConforming2
? this.getSurfacePoint(location2, altitude2)
: this.getPoint(location2, altitude2);
double r1 = s1.getRadius();
double r2 = s2.getRadius();
double d = p1.distanceTo3(p2);
return d <= (r1 + r2);
}
return false;
}
protected double computeLength(Globe globe, boolean followTerrain) {
if (this.positions == null || this.positions.size() < 2) return -1;
if (this.subdividedPositions == null) {
// Subdivide path so as to have at least segments smaller then maxSegmentLenth. If follow
// terrain,
// subdivide so as to have at least lengthTerrainSamplingSteps segments, but no segments
// shorter then
// DEFAULT_MIN_SEGMENT_LENGTH either.
double maxLength = this.maxSegmentLength;
if (followTerrain) {
// Recurse to compute overall path length not following terrain
double pathLength = computeLength(globe, !followTerrain);
// Determine segment length to have enough sampling points
maxLength = pathLength / this.lengthTerrainSamplingSteps;
maxLength =
Math.min(Math.max(maxLength, DEFAULT_MIN_SEGMENT_LENGTH), getMaxSegmentLength());
}
this.subdividedPositions =
subdividePositions(globe, this.positions, maxLength, followTerrain, this.pathType);
}
// Sum each segment length
double length = 0;
Vec4 p1 = globe.computePointFromPosition(this.subdividedPositions.get(0));
for (int i = 1; i < subdividedPositions.size(); i++) {
Vec4 p2 = globe.computePointFromPosition(this.subdividedPositions.get(i));
length += p1.distanceTo3(p2);
p1 = p2;
}
return length;
}
protected void requestTile(DrawContext dc, Tile tile) {
Vec4 centroid = dc.getGlobe().computePointFromPosition(tile.getSector().getCentroid(), 0);
if (this.getReferencePoint() != null)
tile.setPriority(centroid.distanceTo3(this.getReferencePoint()));
RequestTask task = new RequestTask(tile, this);
this.getRequestQ().add(task);
}
/** {@inheritDoc} */
public double distanceTo(Vec4 point) {
if (point == null) {
String msg = Logging.getMessage("nullValue.PointIsNull");
Logging.error(msg);
throw new IllegalArgumentException(msg);
}
double distance = point.distanceTo3(this.center) - this.getRadius();
return (distance < 0d) ? 0d : distance;
}
protected static boolean isNameVisible(
DrawContext dc, PlaceNameService service, Position namePosition) {
double elevation = dc.getVerticalExaggeration() * namePosition.getElevation();
Vec4 namePoint =
dc.getGlobe()
.computePointFromPosition(
namePosition.getLatitude(), namePosition.getLongitude(), elevation);
Vec4 eyeVec = dc.getView().getEyePoint();
double dist = eyeVec.distanceTo3(namePoint);
return dist >= service.getMinDisplayDistance() && dist <= service.getMaxDisplayDistance();
}
public void lookAt(Position lookAtPos, long timeToMove) {
BasicFlyView view = (BasicFlyView) this.getView();
Vec4 lookDirection;
double distanceToSurface;
Vec4 currentLookAtPt = view.getCenterPoint();
Position newPosition;
if (currentLookAtPt == null) {
view.getGlobe().computePointFromPosition(lookAtPos);
double elevAtLookAtPos =
view.getGlobe().getElevation(lookAtPos.getLatitude(), lookAtPos.getLongitude());
newPosition = new Position(lookAtPos, elevAtLookAtPos + 10000);
} else {
Vec4 currentEyePt = view.getEyePoint();
distanceToSurface = currentEyePt.distanceTo3(currentLookAtPt);
lookDirection = currentLookAtPt.subtract3(currentEyePt).normalize3();
Vec4 newLookAtPt = view.getGlobe().computePointFromPosition(lookAtPos);
Vec4 flyToPoint = newLookAtPt.add3(lookDirection.multiply3(-distanceToSurface));
newPosition = view.getGlobe().computePositionFromPoint(flyToPoint);
}
ViewUtil.ViewState viewCoords = view.getViewState(newPosition, lookAtPos);
FlyToFlyViewAnimator panAnimator =
FlyToFlyViewAnimator.createFlyToFlyViewAnimator(
view,
view.getEyePosition(),
newPosition,
view.getHeading(),
viewCoords.getHeading(),
view.getPitch(),
viewCoords.getPitch(),
view.getEyePosition().getElevation(),
viewCoords.getPosition().getElevation(),
timeToMove,
WorldWind.ABSOLUTE);
this.gotoAnimControl.put(VIEW_ANIM_PAN, panAnimator);
this.getView().firePropertyChange(AVKey.VIEW, null, this.getView());
view.firePropertyChange(AVKey.VIEW, null, view);
}
/**
* Add a vertex to the polygon's outer boundary.
*
* @param mousePoint the point at which the mouse was clicked. The new vertex will be placed as
* near as possible to this point, at the elevation of the polygon.
*/
protected void addVertex(Point mousePoint) {
// Try to find the edge that is closest to a ray passing through the screen point. We're trying
// to determine
// the user's intent as to which edge a new two control points should be added to.
Line ray = this.wwd.getView().computeRayFromScreenPoint(mousePoint.getX(), mousePoint.getY());
Vec4 pickPoint = this.intersectPolygonAltitudeAt(ray);
double nearestDistance = Double.MAX_VALUE;
int newVertexIndex = 0;
// Loop through the control points and determine which edge is closest to the pick point
for (int i = 0; i < this.controlPoints.size(); i++) {
ControlPointMarker thisMarker = (ControlPointMarker) this.controlPoints.get(i);
ControlPointMarker nextMarker =
(ControlPointMarker) this.controlPoints.get((i + 1) % this.controlPoints.size());
Vec4 pointOnEdge =
AirspaceEditorUtil.nearestPointOnSegment(thisMarker.point, nextMarker.point, pickPoint);
if (!AirspaceEditorUtil.isPointBehindLineOrigin(ray, pointOnEdge)) {
double d = pointOnEdge.distanceTo3(pickPoint);
if (d < nearestDistance) {
newVertexIndex = i + 1;
nearestDistance = d;
}
}
}
Position newPosition = this.wwd.getModel().getGlobe().computePositionFromPoint(pickPoint);
// Copy the outer boundary list
ArrayList<Position> positionList = new ArrayList<Position>(this.controlPoints.size());
for (LatLon position : this.getPolygon().getOuterBoundary()) {
positionList.add((Position) position);
}
// Add the new vertex
positionList.add(newVertexIndex, newPosition);
this.getPolygon().setOuterBoundary(positionList);
}
protected double computeHorizonDistance(Vec4 eyePoint) {
double horizon = 0;
// Compute largest distance to flat globe 'corners'.
if (this.globe != null && eyePoint != null) {
double dist = 0;
Vec4 p;
// Use max distance to six points around the map
p = this.globe.computePointFromPosition(Angle.POS90, Angle.NEG180, 0); // NW
dist = Math.max(dist, eyePoint.distanceTo3(p));
p = this.globe.computePointFromPosition(Angle.POS90, Angle.POS180, 0); // NE
dist = Math.max(dist, eyePoint.distanceTo3(p));
p = this.globe.computePointFromPosition(Angle.NEG90, Angle.NEG180, 0); // SW
dist = Math.max(dist, eyePoint.distanceTo3(p));
p = this.globe.computePointFromPosition(Angle.NEG90, Angle.POS180, 0); // SE
dist = Math.max(dist, eyePoint.distanceTo3(p));
p = this.globe.computePointFromPosition(Angle.ZERO, Angle.POS180, 0); // E
dist = Math.max(dist, eyePoint.distanceTo3(p));
p = this.globe.computePointFromPosition(Angle.ZERO, Angle.NEG180, 0); // W
dist = Math.max(dist, eyePoint.distanceTo3(p));
horizon = dist;
}
return horizon;
}
protected void onMoveTo(
Position focalPosition,
ViewInputAttributes.DeviceAttributes deviceAttributes,
ViewInputAttributes.ActionAttributes actionAttribs) {
BasicFlyView view = (BasicFlyView) this.getView();
if (view == null) // include this test to ensure any derived implementation performs it
{
return;
}
// We're treating a speed parameter as smoothing here. A greater speed results in greater
// smoothing and
// slower response. Therefore the min speed used at lower altitudes ought to be *greater* than
// the max
// speed used at higher altitudes.
double smoothing = this.getScaleValueElevation(deviceAttributes, actionAttribs);
if (!actionAttribs.isEnableSmoothing()) smoothing = 0.0;
Vec4 currentLookAtPt = view.getCenterPoint();
if (currentLookAtPt == null) {
currentLookAtPt = view.getGlobe().computePointFromPosition(focalPosition);
}
Vec4 currentEyePt = view.getEyePoint();
double distanceToSurface = currentEyePt.distanceTo3(currentLookAtPt);
Vec4 lookDirection = currentEyePt.subtract3(currentLookAtPt).normalize3();
Vec4 newLookAtPt = view.getGlobe().computePointFromPosition(focalPosition);
Vec4 flyToPoint = newLookAtPt.add3(lookDirection.multiply3(distanceToSurface));
Position newPosition = view.getGlobe().computePositionFromPoint(flyToPoint);
ViewUtil.ViewState viewCoords = view.getViewState(newPosition, focalPosition);
this.stopAnimators();
this.gotoAnimControl.put(
VIEW_ANIM_HEADING,
new RotateToAngleAnimator(
view.getHeading(),
viewCoords.getHeading(),
smoothing,
ViewPropertyAccessor.createHeadingAccessor(view)));
this.gotoAnimControl.put(
VIEW_ANIM_PITCH,
new RotateToAngleAnimator(
view.getPitch(),
viewCoords.getPitch(),
smoothing,
ViewPropertyAccessor.createPitchAccessor(view)));
double elevation =
((FlyViewLimits) view.getViewPropertyLimits())
.limitEyeElevation(newPosition, view.getGlobe());
if (elevation != newPosition.getElevation()) {
newPosition = new Position(newPosition, elevation);
}
this.gotoAnimControl.put(
VIEW_ANIM_POSITION,
new MoveToPositionAnimator(
view.getEyePosition(),
newPosition,
smoothing,
ViewPropertyAccessor.createEyePositionAccessor(view)));
view.firePropertyChange(AVKey.VIEW, null, view);
}
