public int countImagesInSector(Sector sector, int levelNumber) {
if (sector == null) {
String msg = Logging.getMessage("nullValue.SectorIsNull");
Logging.logger().severe(msg);
throw new IllegalArgumentException(msg);
}
Level targetLevel = this.levels.getLastLevel();
if (levelNumber >= 0) {
for (int i = levelNumber; i < this.getLevels().getLastLevel().getLevelNumber(); i++) {
if (this.levels.isLevelEmpty(i)) continue;
targetLevel = this.levels.getLevel(i);
break;
}
}
// Collect all the tiles intersecting the input sector.
LatLon delta = targetLevel.getTileDelta();
Angle latOrigin = this.levels.getTileOrigin().getLatitude();
Angle lonOrigin = this.levels.getTileOrigin().getLongitude();
final int nwRow = Tile.computeRow(delta.getLatitude(), sector.getMaxLatitude(), latOrigin);
final int nwCol = Tile.computeColumn(delta.getLongitude(), sector.getMinLongitude(), lonOrigin);
final int seRow = Tile.computeRow(delta.getLatitude(), sector.getMinLatitude(), latOrigin);
final int seCol = Tile.computeColumn(delta.getLongitude(), sector.getMaxLongitude(), lonOrigin);
int numRows = nwRow - seRow + 1;
int numCols = seCol - nwCol + 1;
return numRows * numCols;
}
private void drawTileIDs(DrawContext dc, ArrayList<MercatorTextureTile> tiles) {
java.awt.Rectangle viewport = dc.getView().getViewport();
if (this.textRenderer == null) {
this.textRenderer = new TextRenderer(java.awt.Font.decode("Arial-Plain-13"), true, true);
this.textRenderer.setUseVertexArrays(false);
}
dc.getGL().glDisable(GL.GL_DEPTH_TEST);
dc.getGL().glDisable(GL.GL_BLEND);
dc.getGL().glDisable(GL.GL_TEXTURE_2D);
this.textRenderer.setColor(java.awt.Color.YELLOW);
this.textRenderer.beginRendering(viewport.width, viewport.height);
for (MercatorTextureTile tile : tiles) {
String tileLabel = tile.getLabel();
if (tile.getFallbackTile() != null) tileLabel += "/" + tile.getFallbackTile().getLabel();
LatLon ll = tile.getSector().getCentroid();
Vec4 pt =
dc.getGlobe()
.computePointFromPosition(
ll.getLatitude(),
ll.getLongitude(),
dc.getGlobe().getElevation(ll.getLatitude(), ll.getLongitude()));
pt = dc.getView().project(pt);
this.textRenderer.draw(tileLabel, (int) pt.x, (int) pt.y);
}
this.textRenderer.endRendering();
}
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));
}
public void doActionOnButton3() {
// Sector sector = Sector.fromDegrees( 44d, 46d, -123.3d, -123.2d );
ArrayList<LatLon> latlons = new ArrayList<LatLon>();
latlons.add(LatLon.fromDegrees(45.50d, -123.3d));
// latlons.add( LatLon.fromDegrees( 45.51d, -123.3d ) );
latlons.add(LatLon.fromDegrees(45.52d, -123.3d));
// latlons.add( LatLon.fromDegrees( 45.53d, -123.3d ) );
latlons.add(LatLon.fromDegrees(45.54d, -123.3d));
// latlons.add( LatLon.fromDegrees( 45.55d, -123.3d ) );
latlons.add(LatLon.fromDegrees(45.56d, -123.3d));
// latlons.add( LatLon.fromDegrees( 45.57d, -123.3d ) );
latlons.add(LatLon.fromDegrees(45.58d, -123.3d));
// latlons.add( LatLon.fromDegrees( 45.59d, -123.3d ) );
latlons.add(LatLon.fromDegrees(45.60d, -123.3d));
ElevationModel model = this.wwd.getModel().getGlobe().getElevationModel();
StringBuffer sb = new StringBuffer();
for (LatLon ll : latlons) {
double e = model.getElevation(ll.getLatitude(), ll.getLongitude());
sb.append("\n").append(e);
}
Logging.logger().info(sb.toString());
}
protected void doMoveTo(Position oldReferencePosition, Position newReferencePosition) {
java.util.ArrayList<LatLon> newLocations = new java.util.ArrayList<LatLon>();
for (LatLon ll : this.locations) {
Angle heading = LatLon.greatCircleAzimuth(oldReferencePosition, ll);
Angle pathLength = LatLon.greatCircleDistance(oldReferencePosition, ll);
newLocations.add(LatLon.greatCircleEndPosition(newReferencePosition, heading, pathLength));
}
this.setLocations(newLocations);
}
@Override
protected void doMoveTo(Position oldReferencePosition, Position newReferencePosition) {
if (this.boundaries.getContourCount() == 0) return;
for (int i = 0; i < this.boundaries.getContourCount(); i++) {
ArrayList<LatLon> newLocations = new ArrayList<LatLon>();
for (LatLon ll : this.boundaries.getContour(i)) {
Angle heading = LatLon.greatCircleAzimuth(oldReferencePosition, ll);
Angle pathLength = LatLon.greatCircleDistance(oldReferencePosition, ll);
newLocations.add(LatLon.greatCircleEndPosition(newReferencePosition, heading, pathLength));
}
this.boundaries.setContour(i, newLocations);
}
// We've changed the multi-polygon's list of boundaries; flag the shape as changed.
this.onShapeChanged();
}
private MercatorTextureTile[][] getTilesInSector(Sector sector, int levelNumber) {
if (sector == null) {
String msg = Logging.getMessage("nullValue.SectorIsNull");
Logging.logger().severe(msg);
throw new IllegalArgumentException(msg);
}
Level targetLevel = this.levels.getLastLevel();
if (levelNumber >= 0) {
for (int i = levelNumber; i < this.getLevels().getLastLevel().getLevelNumber(); i++) {
if (this.levels.isLevelEmpty(i)) continue;
targetLevel = this.levels.getLevel(i);
break;
}
}
// Collect all the tiles intersecting the input sector.
LatLon delta = targetLevel.getTileDelta();
Angle latOrigin = this.levels.getTileOrigin().getLatitude();
Angle lonOrigin = this.levels.getTileOrigin().getLongitude();
final int nwRow = Tile.computeRow(delta.getLatitude(), sector.getMaxLatitude(), latOrigin);
final int nwCol = Tile.computeColumn(delta.getLongitude(), sector.getMinLongitude(), lonOrigin);
final int seRow = Tile.computeRow(delta.getLatitude(), sector.getMinLatitude(), latOrigin);
final int seCol = Tile.computeColumn(delta.getLongitude(), sector.getMaxLongitude(), lonOrigin);
int numRows = nwRow - seRow + 1;
int numCols = seCol - nwCol + 1;
MercatorTextureTile[][] sectorTiles = new MercatorTextureTile[numRows][numCols];
for (int row = nwRow; row >= seRow; row--) {
for (int col = nwCol; col <= seCol; col++) {
TileKey key =
new TileKey(targetLevel.getLevelNumber(), row, col, targetLevel.getCacheName());
Sector tileSector = this.levels.computeSectorForKey(key);
MercatorSector mSector = MercatorSector.fromSector(tileSector); // TODO: check
sectorTiles[nwRow - row][col - nwCol] =
new MercatorTextureTile(mSector, targetLevel, row, col);
}
}
return sectorTiles;
}
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++;
}
}
@SuppressWarnings({"UnusedDeclaration"})
protected void doMoved(PositionEvent event) {
if (this.active
&& rubberBandTarget != null
&& this.measureTool.getWwd().getObjectsAtCurrentPosition() != null
&& this.measureTool.getWwd().getObjectsAtCurrentPosition().getTerrainObject() != null) {
if (!isFreeHand()
|| (!measureTool.getMeasureShapeType().equals(MeasureTool.SHAPE_PATH)
&& !measureTool.getMeasureShapeType().equals(MeasureTool.SHAPE_POLYGON))) {
// Rubber band - Move control point and update shape
Position lastPosition = rubberBandTarget.getPosition();
PickedObjectList pol = measureTool.getWwd().getObjectsAtCurrentPosition();
PickedObject to = pol.getTerrainObject();
rubberBandTarget.setPosition(new Position(to.getPosition(), 0));
measureTool.moveControlPoint(rubberBandTarget);
measureTool.firePropertyChange(
MeasureTool.EVENT_POSITION_REPLACE, lastPosition, rubberBandTarget.getPosition());
measureTool.getWwd().redraw();
} else {
// Free hand - Compute distance from current control point (rubber band target)
Position lastPosition = rubberBandTarget.getPosition();
Position newPosition = measureTool.getWwd().getCurrentPosition();
double distance =
LatLon.greatCircleDistance(lastPosition, newPosition).radians
* measureTool.getWwd().getModel().getGlobe().getRadius();
if (distance >= freeHandMinSpacing) {
// Add new control point
measureTool.addControlPoint();
rubberBandTarget =
(MeasureTool.ControlPoint)
getMeasureTool()
.getControlPoints()
.get(getMeasureTool().getControlPoints().size() - 1);
measureTool.getWwd().redraw();
}
}
} else if (this.moving
&& movingTarget != null
&& measureTool.getWwd().getCurrentPosition() != null) {
// Moving the whole shape
Position lastPosition = movingTarget.getPosition();
Position newPosition = measureTool.getWwd().getCurrentPosition();
this.moveToPosition(lastPosition, newPosition);
// Update the tool tip to follow the shape as it moves.
if (measureTool.isShowAnnotation()) measureTool.updateAnnotation(movingTarget.getPosition());
measureTool.getWwd().redraw();
}
}
protected void doMoveTo(Position oldRef, Position newRef) {
if (oldRef == null) {
String message = "nullValue.OldRefIsNull";
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
if (newRef == null) {
String message = "nullValue.NewRefIsNull";
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
super.doMoveTo(oldRef, newRef);
int count = this.locations.size();
LatLon[] newLocations = new LatLon[count];
for (int i = 0; i < count; i++) {
LatLon ll = this.locations.get(i);
double distance = LatLon.greatCircleDistance(oldRef, ll).radians;
double azimuth = LatLon.greatCircleAzimuth(oldRef, ll).radians;
newLocations[i] = LatLon.greatCircleEndPosition(newRef, azimuth, distance);
}
this.setLocations(Arrays.asList(newLocations));
}
/**
* Converts a point from pixel XY coordinates at a specified level of detail into
* latitude/longitude WGS-84 coordinates (in degrees)
*
* @param pixelX X coordinate in pixels
* @param pixelY Y coordinate in pixels
* @param levelOfDetail Level of detail, from 1 (lowest detail) to 23 (highest detail)
* @return LatLon Geodetic coordinates
*/
public static LatLon PixelXYToLatLong(int pixelX, int pixelY, int levelOfDetail) {
double mapSize = (double) calcMapSize(levelOfDetail);
double x = (pixelX - 0.5) / mapSize;
double y = (pixelY - 0.5) / mapSize;
double lon = 360 * x - 180;
double b = Math.pow(Math.E, -4 * Math.PI * (y - 0.5));
double sinLatitude = (b - 1) / (1 + b);
double lat = Math.asin(sinLatitude) * 180 / Math.PI;
return LatLon.fromDegrees(lat, lon);
}
@Override
protected void doMoveTo(
Globe globe, Position oldReferencePosition, Position newReferencePosition) {
if (this.boundaries.getContourCount() == 0) return;
for (int i = 0; i < this.boundaries.getContourCount(); i++) {
List<LatLon> newLocations =
LatLon.computeShiftedLocations(
globe, oldReferencePosition, newReferencePosition, this.boundaries.getContour(i));
this.boundaries.setContour(i, newLocations);
}
// We've changed the multi-polygon's list of boundaries; flag the shape as changed.
this.onShapeChanged();
}
public void doActionOnButton1() {
Logging.logger().info("Zooming to Matterhorn");
View view = this.wwd.getView();
Position matterhorn =
new Position(LatLon.fromDegrees(45.9763888888889d, 7.65833333333333d), 0d);
// Position eyePos = new Position( LatLon.fromDegrees( 46.01066860997058d,
// 7.633097536001656d ), 3363d );
//
// view.setEyePosition( eyePos );
// view.setHeading( Angle.fromDegrees( 156d ));
// view.setPitch( Angle.fromDegrees( 89.9d ));
view.goTo(matterhorn, 5000d);
}
protected static void legacyWmsRestoreStateToParams(
RestorableSupport rs, RestorableSupport.StateObject context, AVList params) {
// WMSTiledImageLayer has historically used a different format for storing LatLon and Sector
// properties
// in the restorable state XML documents. Although WMSTiledImageLayer no longer writes these
// properties,
// we must provide support for reading them here.
Double lat = rs.getStateValueAsDouble(context, AVKey.LEVEL_ZERO_TILE_DELTA + ".Latitude");
Double lon = rs.getStateValueAsDouble(context, AVKey.LEVEL_ZERO_TILE_DELTA + ".Longitude");
if (lat != null && lon != null)
params.setValue(AVKey.LEVEL_ZERO_TILE_DELTA, LatLon.fromDegrees(lat, lon));
Double minLat = rs.getStateValueAsDouble(context, AVKey.SECTOR + ".MinLatitude");
Double minLon = rs.getStateValueAsDouble(context, AVKey.SECTOR + ".MinLongitude");
Double maxLat = rs.getStateValueAsDouble(context, AVKey.SECTOR + ".MaxLatitude");
Double maxLon = rs.getStateValueAsDouble(context, AVKey.SECTOR + ".MaxLongitude");
if (minLat != null && minLon != null && maxLat != null && maxLon != null)
params.setValue(AVKey.SECTOR, Sector.fromDegrees(minLat, maxLat, minLon, maxLon));
}
/**
* Compute the view range footprint on the globe.
*
* @param dc the current <code>DrawContext</code>
* @param steps the number of steps.
* @return an array list of <code>LatLon</code> forming a closed shape.
*/
protected ArrayList<LatLon> computeViewFootPrint(DrawContext dc, int steps) {
ArrayList<LatLon> positions = new ArrayList<LatLon>();
Position eyePos = dc.getView().getEyePosition();
Angle distance =
Angle.fromRadians(
Math.asin(
dc.getView().getFarClipDistance()
/ (dc.getGlobe().getRadius() + eyePos.getElevation())));
if (distance.degrees > 10) {
double headStep = 360d / steps;
Angle heading = Angle.ZERO;
for (int i = 0; i <= steps; i++) {
LatLon p = LatLon.greatCircleEndPosition(eyePos, heading, distance);
positions.add(p);
heading = heading.addDegrees(headStep);
}
return positions;
} else return null;
}
protected void setCursor(MeasureTool.ControlPoint controlPoint) {
// TODO: handle 'rotating' mode cursor is this.isRotating() - when using Alt key on regular
// shapes
if (controlPoint == null) {
setComponentCursor(null);
} else {
if (this.measureTool.isRegularShape()) {
if (this.measureTool.isCornerControl(controlPoint)) {
Angle azimuth =
LatLon.greatCircleAzimuth(
controlPoint.getPosition(), this.measureTool.getCenterPosition());
// Account for view heading in cursor selection
azimuth = azimuth.subtract(this.measureTool.getWwd().getView().getHeading());
setComponentCursor(selectResizeCursor(azimuth));
} else if (this.measureTool.isCenterControl(controlPoint)) {
setComponentCursor(Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR));
}
} else {
// Line, path and polygon
setComponentCursor(Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR));
}
}
}
public void doActionOnButton2() {
ArrayList<LatLon> latlons = new ArrayList<LatLon>();
latlons.add(LatLon.fromDegrees(45.50d, -123.3d));
// latlons.add( LatLon.fromDegrees( 45.51d, -123.3d ) );
latlons.add(LatLon.fromDegrees(45.52d, -123.3d));
// latlons.add( LatLon.fromDegrees( 45.53d, -123.3d ) );
latlons.add(LatLon.fromDegrees(45.54d, -123.3d));
// latlons.add( LatLon.fromDegrees( 45.55d, -123.3d ) );
latlons.add(LatLon.fromDegrees(45.56d, -123.3d));
// latlons.add( LatLon.fromDegrees( 45.57d, -123.3d ) );
latlons.add(LatLon.fromDegrees(45.58d, -123.3d));
// latlons.add( LatLon.fromDegrees( 45.59d, -123.3d ) );
latlons.add(LatLon.fromDegrees(45.60d, -123.3d));
Sector sector = Sector.fromDegrees(44d, 46d, -123d, -121d);
// Sector sector = Sector.boundingSector( latlons );
double[] elevations = new double[latlons.size()];
// request resolution of DTED2 (1degree / 3600 )
double targetResolution = Angle.fromDegrees(1d).radians / 3600;
double resolutionAchieved =
this.wwd
.getModel()
.getGlobe()
.getElevationModel()
.getElevations(sector, latlons, targetResolution, elevations);
StringBuffer sb = new StringBuffer();
for (double e : elevations) {
sb.append("\n").append(e);
}
sb.append("\nresolutionAchieved = ").append(resolutionAchieved);
sb.append(", requested resolution = ").append(targetResolution);
Logging.logger().info(sb.toString());
}
protected void drawIcon(DrawContext dc) {
if (this.getIconFilePath() == null) return;
GL gl = dc.getGL();
OGLStackHandler ogsh = new OGLStackHandler();
try {
// Initialize texture if necessary
Texture iconTexture = dc.getTextureCache().getTexture(this.getIconFilePath());
if (iconTexture == null) {
this.initializeTexture(dc);
iconTexture = dc.getTextureCache().getTexture(this.getIconFilePath());
if (iconTexture == null) {
String msg = Logging.getMessage("generic.ImageReadFailed");
Logging.logger().finer(msg);
return;
}
}
gl.glDisable(GL.GL_DEPTH_TEST);
double width = this.getScaledIconWidth();
double height = this.getScaledIconHeight();
// Load a parallel projection with xy dimensions (viewportWidth, viewportHeight)
// into the GL projection matrix.
java.awt.Rectangle viewport = dc.getView().getViewport();
ogsh.pushProjectionIdentity(gl);
double maxwh = width > height ? width : height;
gl.glOrtho(0d, viewport.width, 0d, viewport.height, -0.6 * maxwh, 0.6 * maxwh);
// Translate and scale
ogsh.pushModelviewIdentity(gl);
double scale = this.computeScale(viewport);
Vec4 locationSW = this.computeLocation(viewport, scale);
gl.glTranslated(locationSW.x(), locationSW.y(), locationSW.z());
// Scale to 0..1 space
gl.glScaled(scale, scale, 1);
gl.glScaled(width, height, 1d);
if (!dc.isPickingMode()) {
gl.glEnable(GL.GL_BLEND);
gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
// Draw background color behind the map
gl.glColor4ub(
(byte) this.backColor.getRed(),
(byte) this.backColor.getGreen(),
(byte) this.backColor.getBlue(),
(byte) (this.backColor.getAlpha() * this.getOpacity()));
dc.drawUnitQuad();
// Draw world map icon
gl.glColor4d(1d, 1d, 1d, this.getOpacity());
gl.glEnable(GL.GL_TEXTURE_2D);
iconTexture.bind();
TextureCoords texCoords = iconTexture.getImageTexCoords();
dc.drawUnitQuad(texCoords);
gl.glBindTexture(GL.GL_TEXTURE_2D, 0);
gl.glDisable(GL.GL_TEXTURE_2D);
// Draw crosshair for current location
gl.glLoadIdentity();
gl.glTranslated(locationSW.x(), locationSW.y(), locationSW.z());
// Scale to width x height space
gl.glScaled(scale, scale, 1);
// Set color
float[] colorRGB = this.color.getRGBColorComponents(null);
gl.glColor4d(colorRGB[0], colorRGB[1], colorRGB[2], this.getOpacity());
// Draw crosshair
Position groundPos = this.computeGroundPosition(dc, dc.getView());
if (groundPos != null) {
int x = (int) (width * (groundPos.getLongitude().degrees + 180) / 360);
int y = (int) (height * (groundPos.getLatitude().degrees + 90) / 180);
int w = 10; // cross branch length
// Draw
gl.glBegin(GL.GL_LINE_STRIP);
gl.glVertex3d(x - w, y, 0);
gl.glVertex3d(x + w + 1, y, 0);
gl.glEnd();
gl.glBegin(GL.GL_LINE_STRIP);
gl.glVertex3d(x, y - w, 0);
gl.glVertex3d(x, y + w + 1, 0);
gl.glEnd();
}
// Draw view footprint in map icon space
if (this.showFootprint) {
this.footPrintPositions = this.computeViewFootPrint(dc, 32);
if (this.footPrintPositions != null) {
gl.glBegin(GL.GL_LINE_STRIP);
LatLon p1 = this.footPrintPositions.get(0);
for (LatLon p2 : this.footPrintPositions) {
int x = (int) (width * (p2.getLongitude().degrees + 180) / 360);
int y = (int) (height * (p2.getLatitude().degrees + 90) / 180);
// Draw
if (LatLon.locationsCrossDateline(p1, p2)) {
int y1 = (int) (height * (p1.getLatitude().degrees + 90) / 180);
gl.glVertex3d(x < width / 2 ? width : 0, (y1 + y) / 2, 0);
gl.glEnd();
gl.glBegin(GL.GL_LINE_STRIP);
gl.glVertex3d(x < width / 2 ? 0 : width, (y1 + y) / 2, 0);
}
gl.glVertex3d(x, y, 0);
p1 = p2;
}
gl.glEnd();
}
}
// Draw 1px border around and inside the map
gl.glBegin(GL.GL_LINE_STRIP);
gl.glVertex3d(0, 0, 0);
gl.glVertex3d(width, 0, 0);
gl.glVertex3d(width, height - 1, 0);
gl.glVertex3d(0, height - 1, 0);
gl.glVertex3d(0, 0, 0);
gl.glEnd();
} else {
// Picking
this.pickSupport.clearPickList();
this.pickSupport.beginPicking(dc);
// Where in the world are we picking ?
Position pickPosition =
computePickPosition(
dc, locationSW, new Dimension((int) (width * scale), (int) (height * scale)));
Color color = dc.getUniquePickColor();
int colorCode = color.getRGB();
this.pickSupport.addPickableObject(colorCode, this, pickPosition, false);
gl.glColor3ub((byte) color.getRed(), (byte) color.getGreen(), (byte) color.getBlue());
dc.drawUnitQuad();
this.pickSupport.endPicking(dc);
this.pickSupport.resolvePick(dc, dc.getPickPoint(), this);
}
} finally {
dc.restoreDefaultDepthTesting();
dc.restoreDefaultCurrentColor();
if (dc.isPickingMode()) dc.restoreDefaultBlending();
ogsh.pop(gl);
}
}
/**
* Move the shape to the specified new position
*
* @param oldPosition Previous position of shape
* @param newPosition New position for shape
*/
protected void moveToPosition(Position oldPosition, Position newPosition) {
Angle distanceAngle = LatLon.greatCircleDistance(oldPosition, newPosition);
Angle azimuthAngle = LatLon.greatCircleAzimuth(oldPosition, newPosition);
measureTool.moveMeasureShape(azimuthAngle, distanceAngle);
measureTool.firePropertyChange(MeasureTool.EVENT_POSITION_REPLACE, oldPosition, newPosition);
}
protected int computeCartesianPolygon(
Globe globe,
List<? extends LatLon> locations,
List<Boolean> edgeFlags,
Vec4[] points,
Boolean[] edgeFlagArray,
Matrix[] transform) {
if (globe == null) {
String message = Logging.getMessage("nullValue.GlobeIsNull");
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
if (locations == null) {
String message = "nullValue.LocationsIsNull";
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
if (points == null) {
String message = "nullValue.LocationsIsNull";
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
if (points.length < (1 + locations.size())) {
String message =
Logging.getMessage(
"generic.ArrayInvalidLength", "points.length < " + (1 + locations.size()));
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
if (transform == null) {
String message = "nullValue.TransformIsNull";
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
if (transform.length < 1) {
String message = Logging.getMessage("generic.ArrayInvalidLength", "transform.length < 1");
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
// Allocate space to hold the list of locations and location vertices.
int locationCount = locations.size();
// Compute the cartesian points for each location.
for (int i = 0; i < locationCount; i++) {
LatLon ll = locations.get(i);
points[i] = globe.computePointFromPosition(ll.getLatitude(), ll.getLongitude(), 0.0);
if (edgeFlagArray != null) edgeFlagArray[i] = (edgeFlags != null) ? edgeFlags.get(i) : true;
}
// Compute the average of the cartesian points.
Vec4 centerPoint = Vec4.computeAveragePoint(Arrays.asList(points));
// Test whether the polygon is closed. If it is not closed, repeat the first vertex.
if (!points[0].equals(points[locationCount - 1])) {
points[locationCount] = points[0];
if (edgeFlagArray != null) edgeFlagArray[locationCount] = edgeFlagArray[0];
locationCount++;
}
// Compute a transform that will map the cartesian points to a local coordinate system centered
// at the average
// of the points and oriented with the globe surface.
Position centerPos = globe.computePositionFromPoint(centerPoint);
Matrix tx = globe.computeSurfaceOrientationAtPosition(centerPos);
Matrix txInv = tx.getInverse();
// Map the cartesian points to a local coordinate space.
for (int i = 0; i < locationCount; i++) {
points[i] = points[i].transformBy4(txInv);
}
transform[0] = tx;
return locationCount;
}
public void doActionOnButton4() {
ArrayList<LatLon> locations = new ArrayList<LatLon>();
locations.add(LatLon.fromDegrees(45.50d, -123.3d));
locations.add(LatLon.fromDegrees(45.52d, -123.3d));
locations.add(LatLon.fromDegrees(45.54d, -123.3d));
locations.add(LatLon.fromDegrees(45.56d, -123.3d));
locations.add(LatLon.fromDegrees(45.58d, -123.3d));
locations.add(LatLon.fromDegrees(45.60d, -123.3d));
locations.add(LatLon.fromDegrees(40.50d, -120.1d));
locations.add(LatLon.fromDegrees(40.52d, -120.2d));
locations.add(LatLon.fromDegrees(40.54d, -120.3d));
locations.add(LatLon.fromDegrees(40.56d, -120.4d));
locations.add(LatLon.fromDegrees(40.58d, -120.5d));
locations.add(LatLon.fromDegrees(40.60d, -120.6d));
// Now, let's find WMSBasicElevationModel
WMSBasicElevationModel wmsbem = null;
ElevationModel model = this.wwd.getModel().getGlobe().getElevationModel();
if (model instanceof CompoundElevationModel) {
CompoundElevationModel cbem = (CompoundElevationModel) model;
for (ElevationModel em : cbem.getElevationModels()) {
// you can have additional checks if you know specific model name, etc.
if (em instanceof WMSBasicElevationModel) {
wmsbem = (WMSBasicElevationModel) em;
break;
}
}
} else if (model instanceof WMSBasicElevationModel) {
wmsbem = (WMSBasicElevationModel) model;
}
if (null != wmsbem) {
ElevationsRetriever retriever =
new ElevationsRetriever(wmsbem, locations, 10000, 30000, new NotifyWhenReady());
retriever.start();
} else {
String message =
Logging.getMessage(
"ElevationModel.ExceptionRequestingElevations",
"No instance of WMSBasicElevationModel was found");
Logging.logger().severe(message);
}
}