/**
* Returns the superoverlay mode (either specified in the request, or the default one)
*
* @return
*/
public static String getSuperoverlayMode(GetMapRequest request, WMS wms) {
String overlayMode = (String) request.getFormatOptions().get("superoverlay_mode");
if (overlayMode != null) {
return overlayMode;
}
overlayMode = (String) request.getFormatOptions().get("overlayMode");
if (overlayMode != null) {
return overlayMode;
} else {
return wms.getKmlSuperoverlayMode();
}
}
/**
* Returns the the kmscore value (either specified in the request, or the default one)
*
* @param mapContent
* @return
*/
public static int getKmScore(GetMapRequest request, WMS wms) {
Object kmscore = request.getFormatOptions().get("kmscore");
if (kmscore != null) {
return Converters.convert(kmscore, Integer.class);
} else {
return wms.getKmScore();
}
}
/**
* Returns the the kmplacemark value (either specified in the request, or the default one)
*
* @param mapContent
* @return
*/
public static boolean getKmplacemark(GetMapRequest request, WMS wms) {
Object kmplacemark = request.getFormatOptions().get("kmplacemark");
if (kmplacemark != null) {
return Converters.convert(kmplacemark, Boolean.class);
} else {
return wms.getKmlPlacemark();
}
}
/**
* Returns the the kmattr value (either specified in the request, or the default one)
*
* @param mapContent
* @return
*/
public static boolean getKMAttr(GetMapRequest request, WMS wms) {
Object kmattr = request.getFormatOptions().get("kmattr");
if (kmattr != null) {
return Converters.convert(kmattr, Boolean.class);
} else {
return wms.getKmlKmAttr();
}
}
/**
* Returns true if the request is GWC compatible
*
* @param mapContent
* @return
*/
public static boolean isRequestGWCCompatible(GetMapRequest request, int layerIndex, WMS wms) {
// check the kml params are the same as the defaults (GWC uses always the defaults)
boolean requestKmAttr = KMLUtils.getKMAttr(request, wms);
if (requestKmAttr != wms.getKmlKmAttr()) {
return false;
}
boolean requestKmplacemark = KMLUtils.getKmplacemark(request, wms);
if (requestKmplacemark != wms.getKmlPlacemark()) {
return false;
}
int requestKmscore = KMLUtils.getKmScore(request, wms);
if (requestKmscore != wms.getKmScore()) {
return false;
}
// check the layer is local
if (request.getLayers().get(layerIndex).getType() == MapLayerInfo.TYPE_REMOTE_VECTOR) {
return false;
}
// check the layer is using the default style
Style requestedStyle = request.getStyles().get(layerIndex);
Style defaultStyle = request.getLayers().get(layerIndex).getDefaultStyle();
if (!defaultStyle.equals(requestedStyle)) {
return false;
}
// check there is no extra filtering applied to the layer
List<Filter> filters = request.getFilter();
if (filters != null && filters.size() > 0 && filters.get(layerIndex) != Filter.INCLUDE) {
return false;
}
// no fiddling with antialiasing settings
String antialias = (String) request.getFormatOptions().get("antialias");
if (antialias != null && !"FULL".equalsIgnoreCase(antialias)) {
return false;
}
// no custom palette
if (request.getPalette() != null) {
return false;
}
// no custom start index
if (request.getStartIndex() != null && request.getStartIndex() != 0) {
return false;
}
// no custom max features
if (request.getMaxFeatures() != null) {
return false;
}
// no sql view params
if (request.getViewParams() != null && request.getViewParams().size() > 0) {
return false;
}
// ok, it seems everything is the same as GWC cached it
return true;
}
GridSubset findBestGridSubset(WMSMapContent map) {
GetMapRequest req = map.getRequest();
Map formatOpts = req.getFormatOptions();
GridSetBroker gridSetBroker = gwc.getGridSetBroker();
GridSet gridSet = null;
// first check format options to see if explicitly specified
if (formatOpts.containsKey("gridset")) {
gridSet = gridSetBroker.get(formatOpts.get("gridset").toString());
}
// next check srs
if (gridSet == null) {
gridSet = gridSetBroker.get(req.getSRS().toUpperCase());
}
if (gridSet != null) {
return GridSubsetFactory.createGridSubSet(gridSet);
}
CoordinateReferenceSystem crs = map.getCoordinateReferenceSystem();
// look up epsg code
Integer epsgCode = null;
try {
epsgCode = CRS.lookupEpsgCode(crs, false);
} catch (Exception e) {
throw new ServiceException("Unable to determine epsg code for " + crs, e);
}
if (epsgCode == null) {
throw new ServiceException("Unable to determine epsg code for " + crs);
}
SRS srs = SRS.getSRS(epsgCode);
// figure out the appropriate grid sub set
Set<GridSubset> gridSubsets = new LinkedHashSet<GridSubset>();
for (MapLayerInfo l : req.getLayers()) {
TileLayer tl = gwc.getTileLayerByName(l.getName());
if (tl == null) {
throw new ServiceException("No tile layer for " + l.getName());
}
List<GridSubset> theseGridSubsets = tl.getGridSubsetsForSRS(srs);
if (gridSubsets.isEmpty()) {
gridSubsets.addAll(theseGridSubsets);
} else {
gridSubsets.retainAll(theseGridSubsets);
}
if (gridSubsets.isEmpty()) {
throw new ServiceException(
"No suitable " + epsgCode + " grid subset for " + req.getLayers());
}
}
if (gridSubsets.size() > 1) {
if (LOGGER.isLoggable(Level.WARNING)) {
StringBuilder msg = new StringBuilder("Found multiple grid subsets: ");
for (GridSubset gs : gridSubsets) {
msg.append(gs.getName()).append(", ");
}
msg.setLength(msg.length() - 2);
msg.append(". Choosing first.");
LOGGER.warning(msg.toString());
}
}
return gridSubsets.iterator().next();
}
@Override
public WebMap produceMap(WMSMapContent map) throws ServiceException, IOException {
GeoPackage geopkg = new GeoPackage();
geopkg.init();
GetMapRequest req = map.getRequest();
List<Layer> layers = map.layers();
List<MapLayerInfo> mapLayers = req.getLayers();
Preconditions.checkState(
layers.size() == mapLayers.size(),
"Number of map layers not same as number of rendered layers");
// list of layers to render directly and include as tiles
List<MapLayerInfo> tileLayers = new ArrayList();
// check mode, one of:
// vector - render vector layers as feature entries and all else as tiles (default)
// hybrid - render vector layers as feature entries, raster layers as raster entries, all
// others as tile entries
// tiled - all layers as a single tile set
Map formatOpts = req.getFormatOptions();
Mode mode =
formatOpts.containsKey("mode")
? Mode.valueOf(((String) formatOpts.get("mode")).toUpperCase())
: Mode.VECTOR;
if (mode == Mode.TILED) {
// tiled mode means render all as map tile layer
tileLayers.addAll(mapLayers);
} else {
// hybrid mode, dump as raw vector or raster unless the request specifically asks for a
// layer to be rendered as tiles
for (int i = 0; i < layers.size(); i++) {
Layer layer = layers.get(i);
MapLayerInfo mapLayer = mapLayers.get(i);
if (layer instanceof FeatureLayer) {
addFeatureLayer(geopkg, (FeatureLayer) layer, mapLayer, map);
} else if (layer instanceof GridCoverageLayer) {
if (mode == Mode.HYBRID) {
addCoverageLayer(geopkg, (GridCoverageLayer) layer, mapLayer, map);
} else {
tileLayers.add(mapLayer);
}
} else {
tileLayers.add(mapLayer);
}
}
}
addTileLayers(geopkg, tileLayers, map);
geopkg.close();
final File dbFile = geopkg.getFile();
final BufferedInputStream bin = new BufferedInputStream(new FileInputStream(dbFile));
RawMap result =
new RawMap(map, bin, MIME_TYPE) {
@Override
public void writeTo(OutputStream out) throws IOException {
String dbFilename = getAttachmentFileName();
if (dbFilename != null) {
dbFilename = dbFilename.substring(0, dbFilename.length() - 4) + ".gpkg";
} else {
// this shouldn't really ever happen, but fallback anyways
dbFilename = "geoserver.gpkg";
}
IOUtils.copy(bin, out);
out.flush();
// JD: disabling zip compression for now
// ZipOutputStream zout = new ZipOutputStream(out);
// zout.putNextEntry(new ZipEntry(dbFilename));
//
// super.writeTo(zout);
// zout.closeEntry();
// zout.close();
bin.close();
try {
dbFile.delete();
} catch (Exception e) {
LOGGER.log(Level.WARNING, "Error deleting file: " + dbFile.getAbsolutePath(), e);
}
}
};
result.setContentDispositionHeader(map, ".gpkg", true);
return result;
}
