private void renderNotRenderedTiles(
Graphics2D destination,
IProgressMonitor monitor,
WMTRenderJob renderJob,
TileRange range,
RasterSymbolizer style,
int tileWorth,
int thisid,
Set<String> notRenderedTiles,
Set<String> renderedTiles)
throws Exception {
checkCancelState(monitor, thisid, false);
// set the listener on the tile range
range.addListener(listener);
// load the missing tiles by sending requests for them
range.loadTiles(monitor);
// block until all the missing tiles have come through (and draw them
// as they are added to the blocking queue
while (!notRenderedTiles.isEmpty()) {
// check that the rendering is not canceled
checkCancelState(monitor, thisid, true);
if (testing) {
System.out.println("BLOCKED: " + thisid); // $NON-NLS-1$
System.out.println(
"waiting on: " + notRenderedTiles.size() + " tiles"); // $NON-NLS-1$ //$NON-NLS-2$
}
Tile tile = null;
try {
Object element = null;
/* get the next tile that is ready to render,
* check after 1 sec if the rendering was canceled
*/
while ((element = tilesToDraw_queue.poll(1000, TimeUnit.MILLISECONDS)) == null) {
checkCancelState(monitor, thisid, true);
}
tile = (Tile) element;
if (testing) {
System.out.println("removed from queue: " + tile.getId()); // $NON-NLS-1$
}
} catch (InterruptedException ex) {
if (testing) {
System.out.println("InterruptedException trying to take: " + ex); // $NON-NLS-1$
}
}
if (testing) {
System.out.println("UNBLOCKED!!!: " + thisid); // $NON-NLS-1$
}
// check that the rendering is not canceled again after block
checkCancelState(monitor, thisid, true);
// check that the tile's bounds are within the current
// context's bounds (if it's not, don't bother drawing it) and also
// only draw tiles that haven't already been drawn (panning fast
// can result in listeners being notified the same tile is ready multiple
// times but we don't want to draw it more than once per render cycle)
// ReferencedEnvelope viewbounds = getContext().getViewportModel().getBounds();
ReferencedEnvelope viewbounds =
renderJob.projectMapToTileCrs(context.getViewportModel().getBounds());
if (tile != null
&& tile.getBufferedImage() != null
&& viewbounds != null
&& viewbounds.intersects(tile.getBounds())
&& !renderedTiles.contains(tile.getId())
&& notRenderedTiles.contains(tile.getId())) {
try {
renderedTiles.add(tile.getId());
renderTile(destination, (WMTTile) tile, style, renderJob);
} catch (Exception exc) {
WMTPlugin.log(
"[BasicWMTRender.render] renderTile failed (2): " + tile.getId(), exc); // $NON-NLS-1$
}
monitor.worked(tileWorth); // inc the monitor work by 1 tile
setState(RENDERING); // tell renderer new data is ready
}
// remove the tile from the not rendered list regardless
// of whether it was actually drawn (this is to prevent
// this render cycle from blocking endlessly waiting for tiles
// that either didn't return or had some error)
notRenderedTiles.remove(tile.getId());
}
}
public void render(Graphics2D destination, Envelope bounds, IProgressMonitor monitor)
throws RenderException {
WMTPlugin.trace("[BasicWMTRender.render] is called"); // $NON-NLS-1$
if (monitor == null) {
monitor = new NullProgressMonitor();
}
monitor.beginTask("Render WMT", 100); // $NON-NLS-1$
setState(STARTING);
ILayer layer = null;
try {
layer = getContext().getLayer();
// assume everything will work fine
layer.setStatus(ILayer.DONE);
layer.setStatusMessage(""); // $NON-NLS-1$
WMTSource wmtSource = getWmtSourceFromLayer(layer);
if (wmtSource == null)
throw new UnsupportedOperationException(Messages.Render_Error_NoSource);
// Layer properties
WMTLayerProperties layerProperties =
new WMTLayerProperties((StyleBlackboard) layer.getStyleBlackboard());
// Get map extent, which should be drawn
ReferencedEnvelope mapExtent = getRenderBounds();
if (mapExtent == null) {
mapExtent = context.getViewportModel().getBounds();
}
// Scale
double scale = getContext().getViewportModel().getScaleDenominator();
WMTPlugin.trace("[BasicWMTRender.render] Scale: " + scale); // $NON-NLS-1$
WMTRenderJob renderJob = null;
try {
renderJob = WMTRenderJob.createRenderJob(mapExtent, scale, wmtSource);
} catch (Exception exc) {
throw new UnsupportedOperationException(Messages.Render_Error_Projection);
}
// Find tiles
Map<String, Tile> tileList =
wmtSource.cutExtentIntoTiles(
renderJob, WMTRenderJob.getScaleFactor(), false, layerProperties);
// if we have nothing to display, return
if (tileList.isEmpty()) {
throw new UnsupportedOperationException(Messages.Render_Error_NoData);
}
// check if this are too many tiles
if ((tileList = checkTooManyTiles(layer, wmtSource, layerProperties, renderJob, tileList))
.isEmpty()) {
throw new UnsupportedOperationException(Messages.Render_Error_TooManyTiles);
}
// Download and display tiles
// look up the preference for caching tiles on-disk or in
// memory and use the proper tilerange for that.
TileRange range = createTileRange(wmtSource, renderJob, tileList);
// create an empty raster symbolizer for rendering
RasterSymbolizer style = styleBuilder.createRasterSymbolizer();
// setup how much each tile is worth for the monitor work %
int tileCount = range.getTileCount();
int tileWorth = (tileCount / 100) * tileCount;
int thisid = 0;
if (testing) {
staticid++;
thisid = staticid;
}
// first render any tiles that are ready and render non-ready tiles with blank images
Map<String, Tile> tiles = range.getTiles();
Set<String> notRenderedTiles = new HashSet<String>();
Set<String> renderedTiles = new HashSet<String>();
renderReadyTiles(
destination,
monitor,
renderJob,
style,
tileWorth,
thisid,
tiles,
notRenderedTiles,
renderedTiles);
setState(RENDERING);
// if the tilerange is not already completed, then load
// the missing tiles
if (!notRenderedTiles.isEmpty()) {
renderNotRenderedTiles(
destination,
monitor,
renderJob,
range,
style,
tileWorth,
thisid,
notRenderedTiles,
renderedTiles);
}
if (testing) {
System.out.println("DONE!!!: " + thisid); // $NON-NLS-1$
}
} catch (UnsupportedOperationException doneExc) {
setDone(monitor);
layer.setStatus(ILayer.ERROR);
layer.setStatusMessage(doneExc.getMessage());
WMTPlugin.log("[BasicWMTRenderer.render] Error: ", doneExc); // $NON-NLS-1$
return;
} catch (CancellationException cancelExc) {
return;
} catch (Exception ex) {
WMTPlugin.log("[BasicWMTRenderer.render] Unexpected Error: ", ex); // $NON-NLS-1$
}
setDone(monitor);
}