FollowPath(String name) {
super(name);
path.add(Position.fromDegrees(0, 0, 1e5));
path.add(Position.fromDegrees(1, 3, 1e5));
path.add(Position.fromDegrees(2, 4, 1e5));
path.add(Position.fromDegrees(3, 5, 1e5));
}
protected int determineAdjustmentSide(Movable dragObject, double factor) {
if (dragObject instanceof SurfaceSector) {
SurfaceSector quad = (SurfaceSector) dragObject;
Sector s = quad.getSector(); // TODO: go over all sectors
Position p = this.getWwd().getCurrentPosition();
if (p == null) {
return NONE;
}
double dN = abs(s.getMaxLatitude().subtract(p.getLatitude()).degrees);
double dS = abs(s.getMinLatitude().subtract(p.getLatitude()).degrees);
double dW = abs(s.getMinLongitude().subtract(p.getLongitude()).degrees);
double dE = abs(s.getMaxLongitude().subtract(p.getLongitude()).degrees);
double sLat = factor * s.getDeltaLatDegrees();
double sLon = factor * s.getDeltaLonDegrees();
if (dN < sLat && dW < sLon) return NORTHWEST;
if (dN < sLat && dE < sLon) return NORTHEAST;
if (dS < sLat && dW < sLon) return SOUTHWEST;
if (dS < sLat && dE < sLon) return SOUTHEAST;
if (dN < sLat) return NORTH;
if (dS < sLat) return SOUTH;
if (dW < sLon) return WEST;
if (dE < sLon) return EAST;
}
return NONE;
}
protected void movePolygon(Point previousMousePoint, Point mousePoint) {
// Intersect a ray through each mouse point, with a geoid passing through the reference
// elevation.
// If either ray fails to intersect the geoid, then ignore this event. Use the difference
// between the two
// intersected positions to move the control point's location.
View view = this.wwd.getView();
Globe globe = this.wwd.getModel().getGlobe();
Position refPos = this.polygon.getReferencePosition();
if (refPos == null) return;
Line ray = view.computeRayFromScreenPoint(mousePoint.getX(), mousePoint.getY());
Line previousRay =
view.computeRayFromScreenPoint(previousMousePoint.getX(), previousMousePoint.getY());
Vec4 vec = AirspaceEditorUtil.intersectGlobeAt(this.wwd, refPos.getElevation(), ray);
Vec4 previousVec =
AirspaceEditorUtil.intersectGlobeAt(this.wwd, refPos.getElevation(), previousRay);
if (vec == null || previousVec == null) {
return;
}
Position pos = globe.computePositionFromPoint(vec);
Position previousPos = globe.computePositionFromPoint(previousVec);
LatLon change = pos.subtract(previousPos);
this.polygon.move(new Position(change.getLatitude(), change.getLongitude(), 0.0));
}
protected void dragWholeShape(DragSelectEvent dragEvent, Movable dragObject) {
View view = getWwd().getView();
EllipsoidalGlobe globe = (EllipsoidalGlobe) getWwd().getModel().getGlobe();
// Compute ref-point position in screen coordinates.
Position refPos = dragObject.getReferencePosition();
if (refPos == null) return;
Vec4 refPoint = globe.computePointFromPosition(refPos);
Vec4 screenRefPoint = view.project(refPoint);
// Compute screen-coord delta since last event.
int dx = dragEvent.getPickPoint().x - dragEvent.getPreviousPickPoint().x;
int dy = dragEvent.getPickPoint().y - dragEvent.getPreviousPickPoint().y;
// Find intersection of screen coord ref-point with globe.
double x = screenRefPoint.x + dx;
double y =
dragEvent.getMouseEvent().getComponent().getSize().height - screenRefPoint.y + dy - 1;
Line ray = view.computeRayFromScreenPoint(x, y);
Intersection inters[] = globe.intersect(ray, refPos.getElevation());
if (inters != null) {
// Intersection with globe. Move reference point to the intersection point.
Position p = globe.computePositionFromPoint(inters[0].getIntersectionPoint());
dragObject.moveTo(p);
}
}
/**
* 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();
}
public void goTo(Position lookAtPos, double distance) {
Globe globe = this.getView().getGlobe();
BasicFlyView view = (BasicFlyView) this.getView();
Position lookFromPos =
new Position(
lookAtPos,
globe.getElevation(lookAtPos.getLatitude(), lookAtPos.getLongitude()) + distance);
// TODO: scale on mid-altitude?
final long MIN_LENGTH_MILLIS = 4000;
final long MAX_LENGTH_MILLIS = 16000;
long timeToMove =
AnimationSupport.getScaledTimeMillisecs(
view.getEyePosition(), lookFromPos, MIN_LENGTH_MILLIS, MAX_LENGTH_MILLIS);
FlyToFlyViewAnimator panAnimator =
FlyToFlyViewAnimator.createFlyToFlyViewAnimator(
view,
view.getEyePosition(),
lookFromPos,
view.getHeading(),
Angle.ZERO,
view.getPitch(),
Angle.ZERO,
view.getEyePosition().getElevation(),
lookFromPos.getElevation(),
timeToMove,
WorldWind.ABSOLUTE);
this.gotoAnimControl.put(VIEW_ANIM_PAN, panAnimator);
this.getView().firePropertyChange(AVKey.VIEW, null, this.getView());
}
protected void assembleVertexControlPoints(DrawContext dc) {
Terrain terrain = dc.getTerrain();
ExtrudedPolygon polygon = this.getPolygon();
Position refPos = polygon.getReferencePosition();
Vec4 refPoint = terrain.getSurfacePoint(refPos.getLatitude(), refPos.getLongitude(), 0);
int altitudeMode = polygon.getAltitudeMode();
double height = polygon.getHeight();
Vec4 vaa = null;
double vaaLength = 0; // used to compute independent length of each cap vertex
double vaLength = 0;
int i = 0;
for (LatLon location : polygon.getOuterBoundary()) {
Vec4 vert;
// Compute the top/cap point.
if (altitudeMode == WorldWind.CONSTANT || !(location instanceof Position)) {
if (vaa == null) {
// Compute the vector lengths of the top and bottom points at the reference position.
vaa = refPoint.multiply3(height / refPoint.getLength3());
vaaLength = vaa.getLength3();
vaLength = refPoint.getLength3();
}
// Compute the bottom point, which is on the terrain.
vert = terrain.getSurfacePoint(location.getLatitude(), location.getLongitude(), 0);
double delta = vaLength - vert.dot3(refPoint) / vaLength;
vert = vert.add3(vaa.multiply3(1d + delta / vaaLength));
} else if (altitudeMode == WorldWind.RELATIVE_TO_GROUND) {
vert =
terrain.getSurfacePoint(
location.getLatitude(),
location.getLongitude(),
((Position) location).getAltitude());
} else // WorldWind.ABSOLUTE
{
vert =
terrain
.getGlobe()
.computePointFromPosition(
location.getLatitude(),
location.getLongitude(),
((Position) location).getAltitude() * terrain.getVerticalExaggeration());
}
Position vertexPosition = this.wwd.getModel().getGlobe().computePositionFromPoint(vert);
this.controlPoints.add(
new ControlPointMarker(
MOVE_VERTEX_ACTION, vertexPosition, vert, this.vertexControlAttributes, i));
i++;
}
}
private void fillPointsPanel() {
int i = 0;
for (Position pos : lineBuilder.getLine().getPositions()) {
if (i == this.pointLabels.length) break;
String las = String.format("Lat %7.4f\u00B0", pos.getLatitude().getDegrees());
String los = String.format("Lon %7.4f\u00B0", pos.getLongitude().getDegrees());
pointLabels[i++].setText(las + " " + los);
}
for (; i < this.pointLabels.length; i++) pointLabels[i++].setText("");
}
public void onSuccess(Position[] positions) {
for (Position p : positions) {
Logging.logger()
.info(
p.getLatitude().degrees
+ ","
+ p.getLongitude().degrees
+ " --> "
+ p.getElevation());
}
}
protected void onVerticalTranslate(
double translateChange,
double totalTranslateChange,
ViewInputAttributes.DeviceAttributes deviceAttributes,
ViewInputAttributes.ActionAttributes actionAttribs) {
this.stopGoToAnimators();
double elevChange =
-(totalTranslateChange * getScaleValueElevation(deviceAttributes, actionAttribs));
View view = this.getView();
Position position = view.getEyePosition();
Position newPos = new Position(position, position.getElevation() + (elevChange));
this.setEyePosition(uiAnimControl, view, newPos, actionAttribs);
view.firePropertyChange(AVKey.VIEW, null, view);
}
protected void setEyePosition(
AnimationController animControl,
View view,
Position position,
ViewInputAttributes.ActionAttributes attrib) {
MoveToPositionAnimator posAnimator =
(MoveToPositionAnimator) animControl.get(VIEW_ANIM_POSITION);
double smoothing = attrib.getSmoothingValue();
if (!(attrib.isEnableSmoothing() && this.isEnableSmoothing())) smoothing = 0.0;
if (smoothing != 0.0) {
double elevation =
((FlyViewLimits) view.getViewPropertyLimits())
.limitEyeElevation(position, view.getGlobe());
if (elevation != position.getElevation()) {
position = new Position(position, elevation);
}
if (posAnimator == null) {
posAnimator =
new MoveToPositionAnimator(
view.getEyePosition(),
position,
smoothing,
OrbitViewPropertyAccessor.createEyePositionAccessor(view));
animControl.put(VIEW_ANIM_POSITION, posAnimator);
} else {
posAnimator.setEnd(position);
posAnimator.start();
}
}
view.firePropertyChange(AVKey.VIEW, null, view);
}
protected Sector resizeShape(Movable dragObject, int side) {
if (dragObject instanceof SurfaceSector) {
SurfaceSector quad = (SurfaceSector) dragObject;
Sector s = quad.getSector(); // TODO: go over all sectors
Position p = this.getWwd().getCurrentPosition();
if (p == null || this.getPreviousPosition() == null) {
return null;
}
Angle dLat = p.getLatitude().subtract(this.getPreviousPosition().getLatitude());
Angle dLon = p.getLongitude().subtract(this.getPreviousPosition().getLongitude());
Angle newMinLat = s.getMinLatitude();
Angle newMinLon = s.getMinLongitude();
Angle newMaxLat = s.getMaxLatitude();
Angle newMaxLon = s.getMaxLongitude();
if (side == NORTH) {
newMaxLat = s.getMaxLatitude().add(dLat);
} else if (side == SOUTH) {
newMinLat = s.getMinLatitude().add(dLat);
} else if (side == EAST) {
newMaxLon = s.getMaxLongitude().add(dLon);
} else if (side == WEST) {
newMinLon = s.getMinLongitude().add(dLon);
} else if (side == NORTHWEST) {
newMaxLat = s.getMaxLatitude().add(dLat);
newMinLon = s.getMinLongitude().add(dLon);
} else if (side == NORTHEAST) {
newMaxLat = s.getMaxLatitude().add(dLat);
newMaxLon = s.getMaxLongitude().add(dLon);
} else if (side == SOUTHWEST) {
newMinLat = s.getMinLatitude().add(dLat);
newMinLon = s.getMinLongitude().add(dLon);
} else if (side == SOUTHEAST) {
newMinLat = s.getMinLatitude().add(dLat);
newMaxLon = s.getMaxLongitude().add(dLon);
}
return new Sector(newMinLat, newMaxLat, newMinLon, newMaxLon);
}
return null;
}
protected void showIntersections(List<Position> intersections) {
this.intersectionsLayer.removeAllRenderables();
// Display the intersections as CYAN points.
PointPlacemarkAttributes intersectionPointAttributes;
intersectionPointAttributes = new PointPlacemarkAttributes();
intersectionPointAttributes.setLineMaterial(Material.CYAN);
intersectionPointAttributes.setScale(6d);
intersectionPointAttributes.setUsePointAsDefaultImage(true);
for (Position p : intersections) {
PointPlacemark pm = new PointPlacemark(p);
pm.setAltitudeMode(WorldWind.CLAMP_TO_GROUND);
pm.setAttributes(intersectionPointAttributes);
pm.setValue(AVKey.DISPLAY_NAME, p.toString());
this.intersectionsLayer.addRenderable(pm);
}
}
static {
path = new ArrayList<Position>();
path.add(Position.fromDegrees(0, 0, 1e5));
path.add(Position.fromDegrees(0, 10, 1e5));
path.add(Position.fromDegrees(0, 20, 1e5));
path.add(Position.fromDegrees(0, 30, 1e5));
path.add(Position.fromDegrees(0, 40, 1e5));
path.add(Position.fromDegrees(0, 50, 1e5));
path.add(Position.fromDegrees(0, 60, 1e5));
path.add(Position.fromDegrees(0, 70, 1e5));
}
protected void performIntersectionTests(final Position curPos) throws InterruptedException {
// Clear the results lists when the user selects a new location.
this.firstIntersectionPositions.clear();
this.sightLines.clear();
// Raise the selected location and the grid points a little above ground just to show we can.
final double height = 5; // meters
// Form the grid.
double gridRadius = GRID_RADIUS.degrees;
Sector sector =
Sector.fromDegrees(
curPos.getLatitude().degrees - gridRadius, curPos.getLatitude().degrees + gridRadius,
curPos.getLongitude().degrees - gridRadius,
curPos.getLongitude().degrees + gridRadius);
this.grid = buildGrid(sector, height, GRID_DIMENSION, GRID_DIMENSION);
this.numGridPoints = grid.size();
// Compute the position of the selected location (incorporate its height).
this.referencePosition = new Position(curPos.getLatitude(), curPos.getLongitude(), height);
this.referencePoint =
terrain.getSurfacePoint(curPos.getLatitude(), curPos.getLongitude(), height);
// // Pre-caching is unnecessary and is useful only when it occurs before the
// intersection
// // calculations. It will incur extra overhead otherwise. The normal intersection
// calculations
// // cause the same caching, making subsequent calculations on the same area
// faster.
// this.preCache(grid, this.referencePosition);
// On the EDT, show the grid.
SwingUtilities.invokeLater(
new Runnable() {
public void run() {
progressBar.setValue(0);
progressBar.setString(null);
clearLayers();
showGrid(grid, referencePosition);
getWwd().redraw();
}
});
// Perform the intersection calculations.
this.startTime = System.currentTimeMillis();
for (Position gridPos : this.grid) // for each grid point.
{
//noinspection ConstantConditions
if (NUM_THREADS > 0) this.threadPool.execute(new Intersector(gridPos));
else performIntersection(gridPos);
}
}
protected String formatMeasurements(Position pos) {
StringBuilder sb = new StringBuilder();
/*
//sb.append(this.unitsFormat.areaNL(this.getLabel(AREA_LABEL), this.getArea()));
sb.append(this.unitsFormat.lengthNL(this.getLabel(PERIMETER_LABEL), this.getLength()));
*/
// sb.append(this.unitsFormat.lengthNL(this.getLabel(WIDTH_LABEL),
// this.shape.getEastWestRadius() * 2));
// sb.append(this.unitsFormat.lengthNL(this.getLabel(LENGTH_LABEL),
// this.shape.getNorthSouthRadius() * 2));
// sb.append(this.unitsFormat.lengthNL(this.getLabel(HEIGHT_LABEL),
// this.shape.getVerticalRadius() * 2));
// sb.append(this.unitsFormat.angleNL(this.getLabel(HEADING_LABEL), this.shape.getHeading()));
// if "activeControlPoint" is in fact one of the control points
if (!this.arePositionsRedundant(pos, this.polygon.getReferencePosition())) {
sb.append(this.unitsFormat.angleNL(this.getLabel(LATITUDE_LABEL), pos.getLatitude()));
sb.append(this.unitsFormat.angleNL(this.getLabel(LONGITUDE_LABEL), pos.getLongitude()));
sb.append(this.unitsFormat.lengthNL(this.getLabel(ALTITUDE_LABEL), pos.getAltitude()));
}
// if "activeControlPoint" is the shape itself
if (this.polygon.getReferencePosition() != null) {
sb.append(
this.unitsFormat.angleNL(
this.getLabel(CENTER_LATITUDE_LABEL),
this.polygon.getReferencePosition().getLatitude()));
sb.append(
this.unitsFormat.angleNL(
this.getLabel(CENTER_LONGITUDE_LABEL),
this.polygon.getReferencePosition().getLongitude()));
sb.append(
this.unitsFormat.lengthNL(
this.getLabel(CENTER_ALTITUDE_LABEL),
this.polygon.getReferencePosition().getAltitude()));
}
return sb.toString();
}
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);
}
protected void showGrid(List<Position> grid, Position cPos) {
this.gridLayer.removeAllRenderables();
// Display the grid points in yellow.
PointPlacemarkAttributes gridPointAttributes;
gridPointAttributes = new PointPlacemarkAttributes();
gridPointAttributes.setLineMaterial(Material.YELLOW);
gridPointAttributes.setScale(6d);
gridPointAttributes.setUsePointAsDefaultImage(true);
for (Position p : grid) {
PointPlacemark pm = new PointPlacemark(p);
pm.setAltitudeMode(WorldWind.RELATIVE_TO_GROUND);
pm.setAttributes(gridPointAttributes);
pm.setLineEnabled(true);
pm.setValue(AVKey.DISPLAY_NAME, p.toString());
this.gridLayer.addRenderable(pm);
}
showCenterPoint(cPos);
}
protected void showGridSightLines(List<Position> grid, Position cPos) {
this.sightLinesLayer.removeAllRenderables();
// Display lines from the center to each grid point.
ShapeAttributes lineAttributes;
lineAttributes = new BasicShapeAttributes();
lineAttributes.setDrawOutline(true);
lineAttributes.setDrawInterior(false);
lineAttributes.setOutlineMaterial(Material.GREEN);
lineAttributes.setOutlineOpacity(0.6);
for (Position p : grid) {
List<Position> endPoints = new ArrayList<Position>();
endPoints.add(cPos);
endPoints.add(new Position(p.getLatitude(), p.getLongitude(), 0));
Path path = new Path(endPoints);
path.setAltitudeMode(WorldWind.RELATIVE_TO_GROUND);
path.setAttributes(lineAttributes);
this.sightLinesLayer.addRenderable(path);
}
}
protected void showCenterPoint(Position cPos) {
// Display the center point in red.
PointPlacemarkAttributes selectedLocationAttributes;
selectedLocationAttributes = new PointPlacemarkAttributes();
selectedLocationAttributes.setLineMaterial(Material.RED);
selectedLocationAttributes.setScale(8d);
selectedLocationAttributes.setUsePointAsDefaultImage(true);
PointPlacemark pm = new PointPlacemark(cPos);
pm.setAltitudeMode(WorldWind.RELATIVE_TO_GROUND);
pm.setAttributes(selectedLocationAttributes);
pm.setValue(AVKey.DISPLAY_NAME, cPos.toString());
pm.setLineEnabled(true);
this.gridLayer.addRenderable(pm);
}
private Info[] buildFreeShapes() {
double elevation = 10e3;
ArrayList<Position> positions = new ArrayList<Position>();
positions.add(
new Position(Angle.fromDegrees(37.8484), Angle.fromDegrees(-119.9754), elevation));
positions.add(
new Position(Angle.fromDegrees(39.3540), Angle.fromDegrees(-110.1526), elevation));
positions.add(
new Position(Angle.fromDegrees(38.3540), Angle.fromDegrees(-100.1526), elevation));
ArrayList<Position> positions2 = new ArrayList<Position>();
positions2.add(new Position(Angle.fromDegrees(0), Angle.fromDegrees(-150), elevation));
positions2.add(new Position(Angle.fromDegrees(25), Angle.fromDegrees(-75), elevation));
positions2.add(new Position(Angle.fromDegrees(50), Angle.fromDegrees(0), elevation));
ArrayList<Position> positions3 = new ArrayList<Position>();
for (double lat = 42, lon = -100; lat <= 45; lat += .1, lon += .1) {
positions3.add(new Position(Angle.fromDegrees(lat), Angle.fromDegrees(lon), elevation));
}
ArrayList<Position> positions4 = new ArrayList<Position>();
positions4.add(new Position(Angle.fromDegrees(90), Angle.fromDegrees(-110), elevation));
positions4.add(new Position(Angle.fromDegrees(-90), Angle.fromDegrees(-110), elevation));
ArrayList<Position> positions5 = new ArrayList<Position>();
for (int i = 0; i < 100; i++) {
positions5.add(
Position.fromDegrees(38.0 + i * 0.0001, 30.0 + i * 0.0001, 1000.0 + i * 5.0));
}
@SuppressWarnings({"UnnecessaryLocalVariable"})
Info[] infos =
new Info[] {
new Info("Short Path", new Polyline(positions)),
new Info("Long Path", new Polyline(positions2)),
new Info("Incremental Path", new Polyline(positions3)),
new Info("Vertical Path", new Polyline(positions4)),
new Info("Small-segment Path", new Polyline(positions5)),
new Info("Quad", new Quadrilateral(Sector.fromDegrees(38, 40, -104, -105), elevation)),
new Info("None", null)
};
return infos;
}
protected void setPolygonHeight(Point previousMousePoint, Point mousePoint) {
// Find the closest points between the rays through each screen point, and the ray from the
// control point
// and in the direction of the globe's surface normal. Compute the elevation difference between
// these two
// points, and use that as the change in polygon height.
Position referencePos = this.polygon.getReferencePosition();
if (referencePos == null) return;
Vec4 referencePoint = this.wwd.getModel().getGlobe().computePointFromPosition(referencePos);
Vec4 surfaceNormal =
this.wwd
.getModel()
.getGlobe()
.computeSurfaceNormalAtLocation(
referencePos.getLatitude(), referencePos.getLongitude());
Line verticalRay = new Line(referencePoint, surfaceNormal);
Line screenRay =
this.wwd.getView().computeRayFromScreenPoint(mousePoint.getX(), mousePoint.getY());
Line previousScreenRay =
this.wwd
.getView()
.computeRayFromScreenPoint(previousMousePoint.getX(), previousMousePoint.getY());
Vec4 pointOnLine = AirspaceEditorUtil.nearestPointOnLine(verticalRay, screenRay);
Vec4 previousPointOnLine =
AirspaceEditorUtil.nearestPointOnLine(verticalRay, previousScreenRay);
Position pos = this.wwd.getModel().getGlobe().computePositionFromPoint(pointOnLine);
Position previousPos =
this.wwd.getModel().getGlobe().computePositionFromPoint(previousPointOnLine);
double elevationChange = pos.getElevation() - previousPos.getElevation();
java.util.List<Position> boundary = new ArrayList<Position>();
for (LatLon ll : this.polygon.getOuterBoundary()) {
boundary.add(new Position(ll, ((Position) ll).getElevation() + elevationChange));
}
this.polygon.setOuterBoundary(boundary);
}
protected Vec4 computeAnnotationPosition(Position pos) {
Vec4 surfacePoint =
this.wwd
.getSceneController()
.getTerrain()
.getSurfacePoint(pos.getLatitude(), pos.getLongitude());
if (surfacePoint == null) {
Globe globe = this.wwd.getModel().getGlobe();
surfacePoint =
globe.computePointFromPosition(
pos.getLatitude(),
pos.getLongitude(),
globe.getElevation(pos.getLatitude(), pos.getLongitude()));
}
return this.wwd.getView().project(surfacePoint);
}
protected List<Position> buildGrid(Sector sector, double height, int nLatCells, int nLonCells) {
List<Position> grid = new ArrayList<Position>((nLatCells + 1) * (nLonCells + 1));
double dLat = sector.getDeltaLatDegrees() / nLatCells;
double dLon = sector.getDeltaLonDegrees() / nLonCells;
for (int j = 0; j <= nLatCells; j++) {
double lat =
j == nLatCells
? sector.getMaxLatitude().degrees
: sector.getMinLatitude().degrees + j * dLat;
for (int i = 0; i <= nLonCells; i++) {
double lon =
i == nLonCells
? sector.getMaxLongitude().degrees
: sector.getMinLongitude().degrees + i * dLon;
grid.add(Position.fromDegrees(lat, lon, height));
}
}
return grid;
}
protected void moveControlPoint(
ControlPointMarker controlPoint, Point lastMousePoint, Point moveToPoint) {
View view = this.wwd.getView();
Globe globe = this.wwd.getModel().getGlobe();
Position refPos = controlPoint.getPosition();
if (refPos == null) return;
Line ray = view.computeRayFromScreenPoint(moveToPoint.getX(), moveToPoint.getY());
Line previousRay = view.computeRayFromScreenPoint(lastMousePoint.getX(), lastMousePoint.getY());
Vec4 vec = AirspaceEditorUtil.intersectGlobeAt(this.wwd, refPos.getElevation(), ray);
Vec4 previousVec =
AirspaceEditorUtil.intersectGlobeAt(this.wwd, refPos.getElevation(), previousRay);
if (vec == null || previousVec == null) {
return;
}
Position pos = globe.computePositionFromPoint(vec);
Position previousPos = globe.computePositionFromPoint(previousVec);
LatLon change = pos.subtract(previousPos);
java.util.List<LatLon> boundary = new ArrayList<LatLon>();
for (LatLon ll : this.polygon.getOuterBoundary()) {
boundary.add(ll);
}
boundary.set(controlPoint.getIndex(), new Position(pos.add(change), refPos.getAltitude()));
// ExtrudedPolygon ensures that the last boundary position is the same as the first. Remove the
// last point
// before setting the boundary.
boundary.remove(boundary.size() - 1);
this.polygon.setOuterBoundary(boundary);
}
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);
}
