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 Vec4 getSurfacePoint(LatLon latlon, double elevation) {
Vec4 point = null;
SceneController sc = this.getApp().getWwd().getSceneController();
Globe globe = this.getApp().getWwd().getModel().getGlobe();
if (sc.getTerrain() != null) {
point =
sc.getTerrain()
.getSurfacePoint(
latlon.getLatitude(),
latlon.getLongitude(),
elevation * sc.getVerticalExaggeration());
}
if (point == null) {
double e = globe.getElevation(latlon.getLatitude(), latlon.getLongitude());
point =
globe.computePointFromPosition(
latlon.getLatitude(),
latlon.getLongitude(),
(e + elevation) * sc.getVerticalExaggeration());
}
return point;
}
public static Sector union(Iterable<? extends Sector> sectors) {
if (sectors == null) {
throw new IllegalArgumentException("Sector List Is Null");
}
Angle minLat = Angle.POS90;
Angle maxLat = Angle.NEG90;
Angle minLon = Angle.POS180;
Angle maxLon = Angle.NEG180;
for (Sector s : sectors) {
if (s == null) {
continue;
}
for (LatLon p : s) {
if (p.getLatitude().degrees < minLat.degrees) {
minLat = p.getLatitude();
}
if (p.getLatitude().degrees > maxLat.degrees) {
maxLat = p.getLatitude();
}
if (p.getLongitude().degrees < minLon.degrees) {
minLon = p.getLongitude();
}
if (p.getLongitude().degrees > maxLon.degrees) {
maxLon = p.getLongitude();
}
}
}
return new Sector(minLat, maxLat, minLon, maxLon);
}
protected Vec4 getPoint(LatLon latlon, double elevation) {
SceneController sc = this.getApp().getWwd().getSceneController();
Globe globe = this.getApp().getWwd().getModel().getGlobe();
double e = globe.getElevation(latlon.getLatitude(), latlon.getLongitude());
return globe.computePointFromPosition(
latlon.getLatitude(),
latlon.getLongitude(),
(e + elevation) * sc.getVerticalExaggeration());
}
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());
}
/**
* Determines whether a latitude/longitude position is within the sector. The sector's angles are
* assumed to be normalized to +/- 90 degrees latitude and +/- 180 degrees longitude. The result
* of the operation is undefined if they are not.
*
* @param latLon the position to test, with angles normalized to +/- π latitude and +/- 2π
* longitude.
* @return <code>true</code> if the position is within the sector, <code>false</code> otherwise.
* @throws IllegalArgumentException if <code>latlon</code> is null.
*/
public final boolean contains(LatLon latLon) {
if (latLon == null) {
throw new IllegalArgumentException("LatLon Is Null");
}
return this.contains(latLon.getLatitude(), latLon.getLongitude());
}
public static Sector boundingSector(Iterable<? extends LatLon> locations) {
if (locations == null) {
throw new IllegalArgumentException("Positions List Is Null");
}
if (!locations.iterator().hasNext()) {
return EMPTY_SECTOR; // TODO: should be returning null
}
double minLat = Angle.POS90.getDegrees();
double minLon = Angle.POS180.getDegrees();
double maxLat = Angle.NEG90.getDegrees();
double maxLon = Angle.NEG180.getDegrees();
for (LatLon p : locations) {
double lat = p.getLatitude().getDegrees();
if (lat < minLat) {
minLat = lat;
}
if (lat > maxLat) {
maxLat = lat;
}
double lon = p.getLongitude().getDegrees();
if (lon < minLon) {
minLon = lon;
}
if (lon > maxLon) {
maxLon = lon;
}
}
return Sector.fromDegrees(minLat, maxLat, minLon, maxLon);
}
protected double computeLocationDistanceDegreesSquared(Sector drawSector, LatLon location) {
double lonOffset = computeHemisphereOffset(drawSector, location);
double dLat = location.getLatitude().degrees - drawSector.getCentroid().getLatitude().degrees;
double dLon =
location.getLongitude().degrees
- drawSector.getCentroid().getLongitude().degrees
+ lonOffset;
return dLat * dLat + dLon * dLon;
}
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;
}
public static Sector[] splitBoundingSectors(Iterable<? extends LatLon> locations) {
if (locations == null) {
throw new IllegalArgumentException("Location In List Is Null");
}
if (!locations.iterator().hasNext()) {
return null;
}
double minLat = Angle.POS90.getDegrees();
double minLon = Angle.POS180.getDegrees();
double maxLat = Angle.NEG90.getDegrees();
double maxLon = Angle.NEG180.getDegrees();
LatLon lastLocation = null;
for (LatLon ll : locations) {
double lat = ll.getLatitude().getDegrees();
if (lat < minLat) {
minLat = lat;
}
if (lat > maxLat) {
maxLat = lat;
}
double lon = ll.getLongitude().getDegrees();
if (lon >= 0 && lon < minLon) {
minLon = lon;
}
if (lon <= 0 && lon > maxLon) {
maxLon = lon;
}
if (lastLocation != null) {
double lastLon = lastLocation.getLongitude().getDegrees();
if (Math.signum(lon) != Math.signum(lastLon)) {
if (Math.abs(lon - lastLon) < 180) {
// Crossing the zero longitude line too
maxLon = 0;
minLon = 0;
}
}
}
lastLocation = ll;
}
if (minLat == maxLat && minLon == maxLon) {
return null;
}
return new Sector[] {
Sector.fromDegrees(minLat, maxLat, minLon, 180), // Sector on eastern hemisphere.
Sector.fromDegrees(minLat, maxLat, -180, maxLon) // Sector on western hemisphere.
};
}
/**
* Determines whether this sector intersects the specified geographic line segment. The line
* segment is specified by a begin location and an end location. The locations are are assumed to
* be connected by a linear path in geographic space. This returns true if any location along that
* linear path intersects this sector, including the begin and end locations.
*
* @param begin the line segment begin location.
* @param end the line segment end location.
* @return true <code>true</code> if this sector intersects the line segment, otherwise <code>
* false</code>.
* @throws IllegalArgumentException if either the begin location or the end location is null.
*/
public boolean intersectsSegment(LatLon begin, LatLon end) {
if (begin == null) {
throw new IllegalArgumentException("Begin Is Null");
}
if (end == null) {
throw new IllegalArgumentException("End Is Null");
}
Vec4 segmentBegin = new Vec4(begin.getLongitude().degrees, begin.getLatitude().degrees, 0);
Vec4 segmentEnd = new Vec4(end.getLongitude().degrees, end.getLatitude().degrees, 0);
Vec4 tmp = segmentEnd.subtract3(segmentBegin);
Vec4 segmentCenter = segmentBegin.add3(segmentEnd).divide3(2);
Vec4 segmentDirection = tmp.normalize3();
double segmentExtent = tmp.getLength3() / 2.0;
LatLon centroid = this.getCentroid();
Vec4 boxCenter = new Vec4(centroid.getLongitude().degrees, centroid.getLatitude().degrees, 0);
double boxExtentX = this.getDeltaLonDegrees() / 2.0;
double boxExtentY = this.getDeltaLatDegrees() / 2.0;
Vec4 diff = segmentCenter.subtract3(boxCenter);
if (Math.abs(diff.x) > (boxExtentX + segmentExtent * Math.abs(segmentDirection.x))) {
return false;
}
if (Math.abs(diff.y) > (boxExtentY + segmentExtent * Math.abs(segmentDirection.y))) {
return false;
}
//noinspection SuspiciousNameCombination
Vec4 segmentPerp = new Vec4(segmentDirection.y, -segmentDirection.x, 0);
return Math.abs(segmentPerp.dot3(diff))
<= (boxExtentX * Math.abs(segmentPerp.x) + boxExtentY * Math.abs(segmentPerp.y));
}
public static Sector boundingSector(LatLon pA, LatLon pB) {
if (pA == null || pB == null) {
throw new IllegalArgumentException("Positions List Is Null");
}
double minLat = pA.getLatitude().degrees;
double minLon = pA.getLongitude().degrees;
double maxLat = pA.getLatitude().degrees;
double maxLon = pA.getLongitude().degrees;
if (pB.getLatitude().degrees < minLat) {
minLat = pB.getLatitude().degrees;
} else if (pB.getLatitude().degrees > maxLat) {
maxLat = pB.getLatitude().degrees;
}
if (pB.getLongitude().degrees < minLon) {
minLon = pB.getLongitude().degrees;
} else if (pB.getLongitude().degrees > maxLon) {
maxLon = pB.getLongitude().degrees;
}
return Sector.fromDegrees(minLat, maxLat, minLon, maxLon);
}
protected void initializePolygon(WorldWindow wwd, Polygon polygon, boolean fitShapeToViewport) {
// Creates a rectangle in the center of the viewport. Attempts to guess at a reasonable size
// and height.
Position position = ShapeUtils.getNewShapePosition(wwd);
Angle heading = ShapeUtils.getNewShapeHeading(wwd, true);
double sizeInMeters =
fitShapeToViewport ? ShapeUtils.getViewportScaleFactor(wwd) : DEFAULT_SHAPE_SIZE_METERS;
java.util.List<LatLon> locations =
ShapeUtils.createSquareInViewport(wwd, position, heading, sizeInMeters);
double maxElevation = -Double.MAX_VALUE;
Globe globe = wwd.getModel().getGlobe();
for (LatLon ll : locations) {
double e = globe.getElevation(ll.getLatitude(), ll.getLongitude());
if (e > maxElevation) maxElevation = e;
}
polygon.setAltitudes(0.0, maxElevation + sizeInMeters);
polygon.setTerrainConforming(true, false);
polygon.setLocations(locations);
}
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 BarycentricQuadrilateral(LatLon p00, LatLon p10, LatLon p11, LatLon p01) {
super(p00, p10, p01);
this.p11 = new Vec4(p11.getLongitude().getRadians(), p11.getLatitude().getRadians(), 0);
this.w11 = this.getBarycentricCoords(this.p11);
}
