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); }