private Map<String, Tile> checkTooManyTiles(
ILayer layer,
WMTSource wmtSource,
WMTLayerProperties layerProperties,
WMTRenderJob renderJob,
Map<String, Tile> tileList) {
int tilesCount = tileList.size();
if (tilesCount > WMTRenderJob.getTileLimitWarning()) {
// too many tiles, let's use the recommended zoom-level (if it wasn't already used)
Boolean selectionAutomatic = layerProperties.getSelectionAutomatic();
if ((selectionAutomatic != null) && (selectionAutomatic == false)) {
tileList.clear();
tileList =
wmtSource.cutExtentIntoTiles(
renderJob, WMTRenderJob.getScaleFactor(), true, layerProperties);
tilesCount = tileList.size();
}
// show a warning about this
layer.setStatus(ILayer.WARNING);
layer.setStatusMessage(Messages.Render_Warning_TooManyTiles);
WMTPlugin.trace("[BasicWMTRender.render] Set WARNING_TOO_MANY_TILES"); // $NON-NLS-1$
}
if (tilesCount > WMTRenderJob.getTileLimitError()) {
// this is just too much, cancel
WMTPlugin.trace("[BasicWMTRender.render] Set ERROR_TOO_MANY_TILES"); // $NON-NLS-1$
return Collections.emptyMap();
}
return tileList;
}
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);
}
@Override
public void draw(MapGraphicContext context) {
// Initialize
ILayer graticule = context.getLayer();
GraticuleStyle style = GraticuleStyle.getStyle(graticule);
// Ensure CRS?
if (graticule instanceof Layer) {
// Initialize CRS?
if (style.isInitCRS()) {
// Only initialize once
style.setInitCRS(false);
// Apply CRS from context
GraticuleCRSConfigurator.apply((Layer) graticule, context.getCRS());
} else if (mismatch(graticule, style)) {
// Apply CRS from
GraticuleCRSConfigurator.apply((Layer) graticule, style.getCRS());
}
}
// Sanity checks
if (MAX_SCALE < context.getMap().getViewportModel().getScaleDenominator()) {
graticule.setStatus(ILayer.ERROR);
graticule.setStatusMessage(Messages.GraticuleGraphic_Maximum_Scale + MAX_SCALE);
return;
}
Unit<?> unit = CRSUtilities.getUnit(graticule.getCRS().getCoordinateSystem());
if (!SI.METER.equals(unit)) {
graticule.setStatus(ILayer.ERROR);
graticule.setStatusMessage(Messages.GraticuleGraphic_Illegal_CRS);
return;
}
final IWorkbench workbench = PlatformUI.getWorkbench();
if (workbench == null) return;
// Start working on layer
graticule.setStatus(ILayer.WORKING);
graticule.setStatusMessage(null);
// Get display to work on
final Display display = workbench.getDisplay();
// Set styles
Font plain = GraticuleStyle.getFontStyle(context).getFont();
Font bold = plain.deriveFont(Font.BOLD);
// Initialize the graphics handle
ViewportGraphics g = context.getGraphics();
// Set font size
g.setFont(bold);
// Get bounds of viewport
ReferencedEnvelope bounds = context.getViewportModel().getBounds();
try {
// Get square size limited to minimum size of 100 pixels
double size = size(context, unit, 100);
// Sanity check
if (size < 100) return;
// Convert square size to pixels
int sx = (int) (size / context.getViewportModel().getPixelSize().x);
int sy = (int) (size / context.getViewportModel().getPixelSize().y);
// Make transform from Graticule to map CRS
MathTransform transform = CRS.findMathTransform(graticule.getCRS(), context.getCRS(), false);
// Transform bounds into Graticule CRS
bounds = bounds.transform(graticule.getCRS(), true);
// Get squares inside bounds
SimpleFeatureIterator it = squares(bounds, size);
// Draw one squares at the time (only top and left lines are drawn)
while (it.hasNext()) {
// Initialize states
int i = 0;
Point current = null;
// Initialize lines
List<Line> lines = new ArrayList<Line>(2);
List<Label> labels = new ArrayList<Label>(2);
// Get next geometry
Geometry geom = (Geometry) it.next().getDefaultGeometry();
// Get coordinates in graticule CRS
Coordinate[] coords = geom.getCoordinates();
// Get x-coordinate label from upper left corner
String tx = getLabel(coords[0].x, size, unit, style);
// Get y-coordinate label from lower left corner
String ty = getLabel(coords[2].y, size, unit, style);
// Insert gap with label?
boolean vgap = isGap(tx, unit, style);
boolean hgap = isGap(ty, unit, style);
// Transform coordinates into Map CRS
coords = JTS.transform(geom, transform).getCoordinates();
// Create lines and labels for this square
for (Coordinate c : coords) {
// Build paths
switch (i) {
case 1:
// -----------------------
// Vertical line
// -----------------------
// Create line path
current =
vert(
display,
g,
sy,
style.getLineWidth(),
current,
context.worldToPixel(c),
hgap,
vgap,
lines);
// Add xx label?
if (hgap) {
labels.add(new Label(current, tx, vgap ? bold : plain));
current = context.worldToPixel(c);
}
break;
case 2:
// -----------------------
// Horizontal line
// -----------------------
// Create line path
current =
horz(
display,
g,
sx,
style.getLineWidth(),
current,
context.worldToPixel(c),
vgap,
hgap,
lines);
// Add yy label?
if (vgap) {
labels.add(new Label(current, ty, hgap ? bold : plain));
current = context.worldToPixel(c);
}
break;
default:
current = context.worldToPixel(c);
break;
}
i++;
}
// Draw lines
for (Line line : lines) line.draw(g, style);
// Draw labels?
if (style.isShowLabels()) for (Label label : labels) label.draw(g, style);
}
// // Get lower left corner coordinates
// int x = llc.x;
// int y = llc.y;
//
// // Print borders
// g.setColor(lc);
// g.setStroke(ViewportGraphics.LINE_SOLID, 5);
//
// // Inner rectangle
// g.drawRect(x + d + l, y + d + l, w - 2 * (d + l), h - 2 * (d + l));
//
// // Make white border
// g.setColor(Color.WHITE);
//
// // Left
// g.drawRect(x, y, d, h);
// g.fillRect(x, y, d, h);
//
// // Bottom
// g.drawRect(x, y, w, d);
// g.fillRect(x, y, w, d);
//
// // Right
// g.drawRect(x + w - d, y, d, h);
// g.fillRect(x + w - d, y, d, h);
//
// // Top
// g.drawRect(x, y + h - d, w, d);
// g.fillRect(x, y + h - d, w, d);
} catch (IOException ex) {
MapGraphicPlugin.log(Messages.GraticuleGraphic_Error, ex);
} catch (FactoryException ex) {
MapGraphicPlugin.log(Messages.GraticuleGraphic_Error, ex);
} catch (MismatchedDimensionException ex) {
MapGraphicPlugin.log(Messages.GraticuleGraphic_Error, ex);
} catch (TransformException ex) {
MapGraphicPlugin.log(Messages.GraticuleGraphic_Error, ex);
}
// Finished working on layer
graticule.setStatus(ILayer.DONE);
}