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;
}
protected static boolean isSectorVisible(
DrawContext dc, Sector sector, double minDistanceSquared, double maxDistanceSquared) {
View view = dc.getView();
Position eyePos = view.getEyePosition();
if (eyePos == null) return false;
Angle lat = clampAngle(eyePos.getLatitude(), sector.getMinLatitude(), sector.getMaxLatitude());
Angle lon =
clampAngle(eyePos.getLongitude(), sector.getMinLongitude(), sector.getMaxLongitude());
Vec4 p = dc.getGlobe().computePointFromPosition(lat, lon, 0d);
double distSquared = dc.getView().getEyePoint().distanceToSquared3(p);
//noinspection RedundantIfStatement
if (minDistanceSquared > distSquared || maxDistanceSquared < distSquared) return false;
return true;
}
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;
}
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 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);
}
}
private boolean needToSplit(DrawContext dc, Sector sector) {
Vec4[] corners = sector.computeCornerPoints(dc.getGlobe(), dc.getVerticalExaggeration());
Vec4 centerPoint = sector.computeCenterPoint(dc.getGlobe(), dc.getVerticalExaggeration());
View view = dc.getView();
double d1 = view.getEyePoint().distanceTo3(corners[0]);
double d2 = view.getEyePoint().distanceTo3(corners[1]);
double d3 = view.getEyePoint().distanceTo3(corners[2]);
double d4 = view.getEyePoint().distanceTo3(corners[3]);
double d5 = view.getEyePoint().distanceTo3(centerPoint);
double minDistance = d1;
if (d2 < minDistance) minDistance = d2;
if (d3 < minDistance) minDistance = d3;
if (d4 < minDistance) minDistance = d4;
if (d5 < minDistance) minDistance = d5;
double cellSize =
(Math.PI * sector.getDeltaLatRadians() * dc.getGlobe().getRadius()) / 20; // TODO
return !(Math.log10(cellSize) <= (Math.log10(minDistance) - this.splitScale));
}
protected boolean isNavSectorVisible(
DrawContext dc, double minDistanceSquared, double maxDistanceSquared) {
if (!navSector.intersects(dc.getVisibleSector())) return false;
View view = dc.getView();
Position eyePos = view.getEyePosition();
if (eyePos == null) return false;
// check for eyePos over globe
if (Double.isNaN(eyePos.getLatitude().getDegrees())
|| Double.isNaN(eyePos.getLongitude().getDegrees())) return false;
Angle lat =
clampAngle(eyePos.getLatitude(), navSector.getMinLatitude(), navSector.getMaxLatitude());
Angle lon =
clampAngle(
eyePos.getLongitude(), navSector.getMinLongitude(), navSector.getMaxLongitude());
Vec4 p = dc.getGlobe().computePointFromPosition(lat, lon, 0d);
double distSquared = dc.getView().getEyePoint().distanceToSquared3(p);
//noinspection RedundantIfStatement
if (minDistanceSquared > distSquared || maxDistanceSquared < distSquared) return false;
return true;
}
@Override
public void render(DrawContext dc) {
if (dc.isPickingMode() && this.isResizeable()) return;
// This is called twice: once during normal rendering, then again during ordered surface
// rendering. During
// normal renering we render both the interior and border shapes. During ordered surface
// rendering, both
// shapes are already added to the DrawContext and both will be individually processed.
// Therefore we just
// call our superclass behavior
if (dc.isOrderedRenderingMode()) {
super.render(dc);
return;
}
if (!this.isResizeable()) {
if (this.hasSelection()) {
this.doRender(dc);
}
return;
}
PickedObjectList pos = dc.getPickedObjects();
PickedObject terrainObject = pos != null ? pos.getTerrainObject() : null;
if (terrainObject == null) return;
if (this.getStartPosition() != null) {
Position end = terrainObject.getPosition();
if (!this.getStartPosition().equals(end)) {
this.setEndPosition(end);
this.setSector(Sector.boundingSector(this.getStartPosition(), this.getEndPosition()));
this.doRender(dc);
}
} else {
this.setStartPosition(pos.getTerrainObject().getPosition());
}
}
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;
}
public BufferedImage composeImageForSector(
Sector sector,
int imageWidth,
int imageHeight,
int levelNumber,
String mimeType,
boolean abortOnError,
BufferedImage image) {
if (sector == null) {
String message = Logging.getMessage("nullValue.SectorIsNull");
Logging.logger().severe(message);
throw new IllegalStateException(message);
}
if (levelNumber < 0) {
levelNumber = this.levels.getLastLevel().getLevelNumber();
} else if (levelNumber > this.levels.getLastLevel().getLevelNumber()) {
Logging.logger()
.warning(
Logging.getMessage(
"generic.LevelRequestedGreaterThanMaxLevel",
levelNumber,
this.levels.getLastLevel().getLevelNumber()));
levelNumber = this.levels.getLastLevel().getLevelNumber();
}
MercatorTextureTile[][] tiles = this.getTilesInSector(sector, levelNumber);
if (tiles.length == 0 || tiles[0].length == 0) {
Logging.logger().severe(Logging.getMessage("layers.TiledImageLayer.NoImagesAvailable"));
return null;
}
if (image == null)
image = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_RGB);
Graphics2D g = image.createGraphics();
for (MercatorTextureTile[] row : tiles) {
for (MercatorTextureTile tile : row) {
if (tile == null) continue;
BufferedImage tileImage;
try {
tileImage = this.getImage(tile, mimeType);
double sh =
((double) imageHeight / (double) tileImage.getHeight())
* (tile.getSector().getDeltaLat().divide(sector.getDeltaLat()));
double sw =
((double) imageWidth / (double) tileImage.getWidth())
* (tile.getSector().getDeltaLon().divide(sector.getDeltaLon()));
double dh =
imageHeight
* (-tile.getSector().getMaxLatitude().subtract(sector.getMaxLatitude()).degrees
/ sector.getDeltaLat().degrees);
double dw =
imageWidth
* (tile.getSector().getMinLongitude().subtract(sector.getMinLongitude()).degrees
/ sector.getDeltaLon().degrees);
AffineTransform txf = g.getTransform();
g.translate(dw, dh);
g.scale(sw, sh);
g.drawImage(tileImage, 0, 0, null);
g.setTransform(txf);
} catch (Exception e) {
if (abortOnError) throw new RuntimeException(e);
String message =
Logging.getMessage("generic.ExceptionWhileRequestingImage", tile.getPath());
Logging.logger().log(java.util.logging.Level.WARNING, message, e);
}
}
}
return image;
}
public static DataRaster wrapAsGeoreferencedRaster(BufferedImage image, AVList params) {
if (null == image) {
String message = Logging.getMessage("nullValue.ImageIsNull");
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
if (null == params) {
String msg = Logging.getMessage("nullValue.AVListIsNull");
Logging.logger().finest(msg);
throw new IllegalArgumentException(msg);
}
if (params.hasKey(AVKey.WIDTH)) {
int width = (Integer) params.getValue(AVKey.WIDTH);
if (width != image.getWidth()) {
String msg =
Logging.getMessage("generic.InvalidWidth", "" + width + "!=" + image.getWidth());
Logging.logger().finest(msg);
throw new IllegalArgumentException(msg);
}
}
if (params.hasKey(AVKey.HEIGHT)) {
int height = (Integer) params.getValue(AVKey.HEIGHT);
if (height != image.getHeight()) {
String msg =
Logging.getMessage("generic.InvalidHeight", "" + height + "!=" + image.getHeight());
Logging.logger().finest(msg);
throw new IllegalArgumentException(msg);
}
}
if (!params.hasKey(AVKey.SECTOR)) {
String msg = Logging.getMessage("generic.MissingRequiredParameter", AVKey.SECTOR);
Logging.logger().finest(msg);
throw new IllegalArgumentException(msg);
}
Sector sector = (Sector) params.getValue(AVKey.SECTOR);
if (null == sector) {
String msg = Logging.getMessage("nullValue.SectorIsNull");
Logging.logger().severe(msg);
throw new IllegalArgumentException(msg);
}
if (!params.hasKey(AVKey.COORDINATE_SYSTEM)) {
// assume Geodetic Coordinate System
params.setValue(AVKey.COORDINATE_SYSTEM, AVKey.COORDINATE_SYSTEM_GEOGRAPHIC);
}
String cs = params.getStringValue(AVKey.COORDINATE_SYSTEM);
if (!params.hasKey(AVKey.PROJECTION_EPSG_CODE)) {
if (AVKey.COORDINATE_SYSTEM_GEOGRAPHIC.equals(cs)) {
// assume WGS84
params.setValue(AVKey.PROJECTION_EPSG_CODE, GeoTiff.GCS.WGS_84);
} else {
String msg =
Logging.getMessage("generic.MissingRequiredParameter", AVKey.PROJECTION_EPSG_CODE);
Logging.logger().finest(msg);
throw new IllegalArgumentException(msg);
}
}
// if PIXEL_WIDTH is specified, we are not overriding it because UTM images
// will have different pixel size
if (!params.hasKey(AVKey.PIXEL_WIDTH)) {
if (AVKey.COORDINATE_SYSTEM_GEOGRAPHIC.equals(cs)) {
double pixelWidth = sector.getDeltaLonDegrees() / (double) image.getWidth();
params.setValue(AVKey.PIXEL_WIDTH, pixelWidth);
} else {
String msg = Logging.getMessage("generic.MissingRequiredParameter", AVKey.PIXEL_WIDTH);
Logging.logger().finest(msg);
throw new IllegalArgumentException(msg);
}
}
// if PIXEL_HEIGHT is specified, we are not overriding it
// because UTM images will have different pixel size
if (!params.hasKey(AVKey.PIXEL_HEIGHT)) {
if (AVKey.COORDINATE_SYSTEM_GEOGRAPHIC.equals(cs)) {
double pixelHeight = sector.getDeltaLatDegrees() / (double) image.getHeight();
params.setValue(AVKey.PIXEL_HEIGHT, pixelHeight);
} else {
String msg = Logging.getMessage("generic.MissingRequiredParameter", AVKey.PIXEL_HEIGHT);
Logging.logger().finest(msg);
throw new IllegalArgumentException(msg);
}
}
if (!params.hasKey(AVKey.PIXEL_FORMAT)) {
params.setValue(AVKey.PIXEL_FORMAT, AVKey.IMAGE);
} else if (!AVKey.IMAGE.equals(params.getStringValue(AVKey.PIXEL_FORMAT))) {
String msg =
Logging.getMessage(
"generic.UnknownValueForKey",
params.getStringValue(AVKey.PIXEL_FORMAT),
AVKey.PIXEL_FORMAT);
Logging.logger().severe(msg);
throw new IllegalArgumentException(msg);
}
if (!params.hasKey(AVKey.ORIGIN) && AVKey.COORDINATE_SYSTEM_GEOGRAPHIC.equals(cs)) {
// set UpperLeft corner as the origin, if not specified
LatLon origin = new LatLon(sector.getMaxLatitude(), sector.getMinLongitude());
params.setValue(AVKey.ORIGIN, origin);
}
if (!params.hasKey(AVKey.DATE_TIME)) {
// add NUL (\0) termination as required by TIFF v6 spec (20 bytes length)
String timestamp = String.format("%1$tY:%1$tm:%1$td %tT\0", Calendar.getInstance());
params.setValue(AVKey.DATE_TIME, timestamp);
}
if (!params.hasKey(AVKey.VERSION)) {
params.setValue(AVKey.VERSION, Version.getVersion());
}
boolean hasAlpha = (null != image.getColorModel() && image.getColorModel().hasAlpha());
params.setValue(AVKey.RASTER_HAS_ALPHA, hasAlpha);
return new BufferedImageRaster(sector, image, params);
}
protected void doDrawOnTo(BufferedImageRaster canvas) {
Sector sector = this.getSector();
if (null == sector) {
String message = Logging.getMessage("nullValue.SectorIsNull");
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
if (!sector.intersects(canvas.getSector())) {
return;
}
java.awt.Graphics2D g2d = null;
java.awt.Shape prevClip = null;
java.awt.Composite prevComposite = null;
java.lang.Object prevInterpolation = null, prevAntialiasing = null;
try {
int canvasWidth = canvas.getWidth();
int canvasHeight = canvas.getHeight();
// Apply the transform that correctly maps the image onto the canvas.
java.awt.geom.AffineTransform transform =
this.computeSourceToDestTransform(
this.getWidth(),
this.getHeight(),
this.getSector(),
canvasWidth,
canvasHeight,
canvas.getSector());
AffineTransformOp op = new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);
Rectangle2D rect = op.getBounds2D(this.getBufferedImage());
int clipWidth =
(int) Math.ceil((rect.getMaxX() >= canvasWidth) ? canvasWidth : rect.getMaxX());
int clipHeight =
(int) Math.ceil((rect.getMaxY() >= canvasHeight) ? canvasHeight : rect.getMaxY());
if (clipWidth <= 0 || clipHeight <= 0) {
return;
}
g2d = canvas.getGraphics();
prevClip = g2d.getClip();
prevComposite = g2d.getComposite();
prevInterpolation = g2d.getRenderingHint(RenderingHints.KEY_INTERPOLATION);
prevAntialiasing = g2d.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
// Set the alpha composite for appropriate alpha blending.
g2d.setComposite(java.awt.AlphaComposite.SrcOver);
g2d.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2d.drawImage(this.getBufferedImage(), transform, null);
}
// catch (java.awt.image.ImagingOpException ioe)
// {
// // If we catch a ImagingOpException, then the transformed image has a width or
// height of 0.
// // This indicates that there is no intersection between the source image and the
// canvas,
// // or the intersection is smaller than one pixel.
// }
// catch (java.awt.image.RasterFormatException rfe)
// {
// // If we catch a RasterFormatException, then the transformed image has a width or
// height of 0.
// // This indicates that there is no intersection between the source image and the
// canvas,
// // or the intersection is smaller than one pixel.
// }
catch (Throwable t) {
String reason = WWUtil.extractExceptionReason(t);
Logging.logger().log(java.util.logging.Level.SEVERE, reason, t);
} finally {
// Restore the previous clip, composite, and transform.
try {
if (null != g2d) {
if (null != prevClip) g2d.setClip(prevClip);
if (null != prevComposite) g2d.setComposite(prevComposite);
if (null != prevInterpolation)
g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, prevInterpolation);
if (null != prevAntialiasing)
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, prevAntialiasing);
}
} catch (Throwable t) {
Logging.logger().log(java.util.logging.Level.FINEST, WWUtil.extractExceptionReason(t), t);
}
}
}
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;
}
