public RenderedImageMap produceMap(final WMSMapContext mapContext, final boolean tiled)
throws ServiceException {
System.setProperty("tolerance", "0.333");
final MapDecorationLayout layout = findDecorationLayout(mapContext, tiled);
Rectangle paintArea = new Rectangle(0, 0, mapContext.getMapWidth(),
mapContext.getMapHeight());
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.fine("setting up " + paintArea.width + "x" + paintArea.height + " image");
}
// extra antialias setting
final GetMapRequest request = mapContext.getRequest();
String antialias = (String) request.getFormatOptions().get("antialias");
if (antialias != null)
antialias = antialias.toUpperCase();
// figure out a palette for buffered image creation
IndexColorModel palette = null;
final InverseColorMapOp paletteInverter = mapContext.getPaletteInverter();
final boolean transparent = mapContext.isTransparent() && isTransparencySupported();
final Color bgColor = mapContext.getBgColor();
if (paletteInverter != null && AA_NONE.equals(antialias)) {
palette = paletteInverter.getIcm();
} else if (AA_NONE.equals(antialias)) {
PaletteExtractor pe = new PaletteExtractor(transparent ? null : bgColor);
MapLayer[] layers = mapContext.getLayers();
for (int i = 0; i < layers.length; i++) {
pe.visit(layers[i].getStyle());
if (!pe.canComputePalette())
break;
}
if (pe.canComputePalette())
palette = pe.getPalette();
}
// before even preparing the rendering surface, check it's not too big,
// if so, throw a service exception
long maxMemory = wms.getMaxRequestMemory() * KB;
// ... base image memory
long memory = getDrawingSurfaceMemoryUse(paintArea.width, paintArea.height, palette,
transparent);
// .. use a fake streaming renderer to evaluate the extra back buffers used when rendering
// multiple featureTypeStyles against the same layer
StreamingRenderer testRenderer = new StreamingRenderer();
testRenderer.setContext(mapContext);
memory += testRenderer.getMaxBackBufferMemory(paintArea.width, paintArea.height);
if (maxMemory > 0 && memory > maxMemory) {
long kbUsed = memory / KB;
long kbMax = maxMemory / KB;
throw new ServiceException("Rendering request would use " + kbUsed + "KB, whilst the "
+ "maximum memory allowed is " + kbMax + "KB");
}
// TODO: allow rendering to continue with vector layers
// TODO: allow rendering to continue with layout
// TODO: handle rotated rasters
// TODO: handle color conversions
// TODO: handle meta-tiling
// TODO: how to handle timeout here? I guess we need to move it into the dispatcher?
RenderedImage image = null;
// fast path for pure coverage rendering
if (DefaultWebMapService.isDirectRasterPathEnabled() &&
mapContext.getLayerCount() == 1
&& mapContext.getAngle() == 0.0
&& (layout == null || layout.isEmpty())) {
List<GridCoverage2D> renderedCoverages = new ArrayList<GridCoverage2D>(2);
try {
image = directRasterRender(mapContext, 0, renderedCoverages);
} catch (Exception e) {
throw new ServiceException("Error rendering coverage on the fast path", e);
}
if (image != null) {
RenderedImageMap result = new RenderedImageMap(mapContext, image, getMimeType());
result.setRenderedCoverages(renderedCoverages);
return result;
}
}
// we use the alpha channel if the image is transparent or if the meta tiler
// is enabled, since apparently the Crop operation inside the meta-tiler
// generates striped images in that case (see GEOS-
boolean useAlpha = transparent || MetatileMapOutputFormat.isRequestTiled(request, this);
final RenderedImage preparedImage = prepareImage(paintArea.width, paintArea.height,
palette, useAlpha);
final Map<RenderingHints.Key, Object> hintsMap = new HashMap<RenderingHints.Key, Object>();
final Graphics2D graphic = ImageUtils.prepareTransparency(transparent, bgColor,
preparedImage, hintsMap);
// set up the antialias hints
if (AA_NONE.equals(antialias)) {
hintsMap.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
if (preparedImage.getColorModel() instanceof IndexColorModel) {
// otherwise we end up with dithered colors where the match is
// not 100%
hintsMap.put(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
}
} else if (AA_TEXT.equals(antialias)) {
hintsMap.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
hintsMap.put(RenderingHints.KEY_TEXT_ANTIALIASING,
RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
} else {
if (antialias != null && !AA_FULL.equals(antialias)) {
LOGGER.warning("Unrecognized antialias setting '" + antialias
+ "', valid values are " + AA_SETTINGS);
}
hintsMap.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
}
// these two hints improve text layout in diagonal labels and reduce artifacts
// in line rendering (without hampering performance)
hintsMap.put(RenderingHints.KEY_FRACTIONALMETRICS,
RenderingHints.VALUE_FRACTIONALMETRICS_ON);
hintsMap.put(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
// turn off/on interpolation rendering hint
if (wms != null) {
if (WMSInterpolation.Nearest.equals(wms.getInterpolation())) {
hintsMap.put(JAI.KEY_INTERPOLATION, NN_INTERPOLATION);
hintsMap.put(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
} else if (WMSInterpolation.Bilinear.equals(wms.getInterpolation())) {
hintsMap.put(JAI.KEY_INTERPOLATION, BIL_INTERPOLATION);
hintsMap.put(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BILINEAR);
} else if (WMSInterpolation.Bicubic.equals(wms.getInterpolation())) {
hintsMap.put(JAI.KEY_INTERPOLATION, BIC_INTERPOLATION);
hintsMap.put(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BICUBIC);
}
}
// make sure the hints are set before we start rendering the map
graphic.setRenderingHints(hintsMap);
RenderingHints hints = new RenderingHints(hintsMap);
GTRenderer renderer;
if (DefaultWebMapService.useShapefileRenderer()) {
renderer = new ShapefileRenderer();
} else {
StreamingRenderer sr = new StreamingRenderer();
sr.setThreadPool(DefaultWebMapService.getRenderingPool());
renderer = sr;
}
renderer.setContext(mapContext);
renderer.setJava2DHints(hints);
// setup the renderer hints
Map<Object, Object> rendererParams = new HashMap<Object, Object>();
rendererParams.put("optimizedDataLoadingEnabled", new Boolean(true));
rendererParams.put("renderingBuffer", new Integer(mapContext.getBuffer()));
rendererParams.put("maxFiltersToSendToDatastore", DefaultWebMapService.getMaxFilterRules());
rendererParams.put(ShapefileRenderer.SCALE_COMPUTATION_METHOD_KEY,
ShapefileRenderer.SCALE_OGC);
if (AA_NONE.equals(antialias)) {
rendererParams.put(ShapefileRenderer.TEXT_RENDERING_KEY,
StreamingRenderer.TEXT_RENDERING_STRING);
} else {
rendererParams.put(ShapefileRenderer.TEXT_RENDERING_KEY,
StreamingRenderer.TEXT_RENDERING_ADAPTIVE);
}
if (DefaultWebMapService.isLineWidthOptimizationEnabled()) {
rendererParams.put(StreamingRenderer.LINE_WIDTH_OPTIMIZATION_KEY, true);
}
// turn on advanced projection handling
rendererParams.put(StreamingRenderer.ADVANCED_PROJECTION_HANDLING_KEY, true);
if(DefaultWebMapService.isContinuousMapWrappingEnabled()) {
rendererParams.put(StreamingRenderer.CONTINUOUS_MAP_WRAPPING, true);
}
// see if the user specified a dpi
if (mapContext.getRequest().getFormatOptions().get("dpi") != null) {
rendererParams.put(StreamingRenderer.DPI_KEY, ((Integer) mapContext.getRequest()
.getFormatOptions().get("dpi")));
}
boolean kmplacemark = false;
if (mapContext.getRequest().getFormatOptions().get("kmplacemark") != null)
kmplacemark = ((Boolean) mapContext.getRequest().getFormatOptions().get("kmplacemark"))
.booleanValue();
if (kmplacemark) {
// create a StyleVisitor that copies a style, but removes the
// PointSymbolizers and TextSymbolizers
KMLStyleFilteringVisitor dupVisitor = new KMLStyleFilteringVisitor();
// Remove PointSymbolizers and TextSymbolizers from the
// layers' Styles to prevent their rendering on the
// raster image. Both are better served with the
// placemarks.
MapLayer[] layers = mapContext.getLayers();
for (int i = 0; i < layers.length; i++) {
Style style = layers[i].getStyle();
style.accept(dupVisitor);
Style copy = (Style) dupVisitor.getCopy();
layers[i].setStyle(copy);
}
}
renderer.setRendererHints(rendererParams);
// if abort already requested bail out
// if (this.abortRequested) {
// graphic.dispose();
// return null;
// }
// enforce no more than x rendering errors
int maxErrors = wms.getMaxRenderingErrors();
MaxErrorEnforcer errorChecker = new MaxErrorEnforcer(renderer, maxErrors);
// Add a render listener that ignores well known rendering exceptions and reports back non
// ignorable ones
final RenderExceptionStrategy nonIgnorableExceptionListener;
nonIgnorableExceptionListener = new RenderExceptionStrategy(renderer);
renderer.addRenderListener(nonIgnorableExceptionListener);
// setup the timeout enforcer (the enforcer is neutral when the timeout is 0)
int maxRenderingTime = wms.getMaxRenderingTime() * 1000;
RenderingTimeoutEnforcer timeout = new RenderingTimeoutEnforcer(maxRenderingTime, renderer,
graphic);
timeout.start();
try {
// finally render the image;
renderer.paint(graphic, paintArea, mapContext.getRenderingArea(),
mapContext.getRenderingTransform());
// apply watermarking
if (layout != null) {
try {
layout.paint(graphic, paintArea, mapContext);
} catch (Exception e) {
throw new ServiceException("Problem occurred while trying to watermark data", e);
}
}
} finally {