source: josm/trunk/src/org/openstreetmap/josm/data/imagery/WMTSTileSource.java@ 19050

Last change on this file since 19050 was 19050, checked in by taylor.smock, 4 weeks ago

Revert most var changes from r19048, fix most new compile warnings and checkstyle issues

Also, document why various ErrorProne checks were originally disabled and fix
generic SonarLint issues.
  • Property svn:eol-style set to native
File size: 49.1 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.data.imagery;
3
4import static javax.xml.stream.XMLStreamConstants.END_ELEMENT;
5import static javax.xml.stream.XMLStreamConstants.START_ELEMENT;
6import static org.openstreetmap.josm.data.imagery.GetCapabilitiesParseHelper.QN_OWS_DCP;
7import static org.openstreetmap.josm.data.imagery.GetCapabilitiesParseHelper.QN_OWS_GET;
8import static org.openstreetmap.josm.data.imagery.GetCapabilitiesParseHelper.QN_OWS_HTTP;
9import static org.openstreetmap.josm.data.imagery.GetCapabilitiesParseHelper.QN_OWS_IDENTIFIER;
10import static org.openstreetmap.josm.data.imagery.GetCapabilitiesParseHelper.QN_OWS_LOWER_CORNER;
11import static org.openstreetmap.josm.data.imagery.GetCapabilitiesParseHelper.QN_OWS_OPERATION;
12import static org.openstreetmap.josm.data.imagery.GetCapabilitiesParseHelper.QN_OWS_OPERATIONS_METADATA;
13import static org.openstreetmap.josm.data.imagery.GetCapabilitiesParseHelper.QN_OWS_SUPPORTED_CRS;
14import static org.openstreetmap.josm.data.imagery.GetCapabilitiesParseHelper.QN_OWS_TITLE;
15import static org.openstreetmap.josm.data.imagery.GetCapabilitiesParseHelper.QN_OWS_UPPER_CORNER;
16import static org.openstreetmap.josm.data.imagery.GetCapabilitiesParseHelper.QN_OWS_WGS84_BOUNDING_BOX;
17import static org.openstreetmap.josm.tools.I18n.tr;
18
19import java.awt.Point;
20import java.io.ByteArrayInputStream;
21import java.io.IOException;
22import java.io.InputStream;
23import java.nio.charset.StandardCharsets;
24import java.nio.file.InvalidPathException;
25import java.util.ArrayList;
26import java.util.Arrays;
27import java.util.Collection;
28import java.util.Collections;
29import java.util.Deque;
30import java.util.HashMap;
31import java.util.LinkedHashSet;
32import java.util.LinkedList;
33import java.util.List;
34import java.util.Map;
35import java.util.Map.Entry;
36import java.util.Objects;
37import java.util.Optional;
38import java.util.SortedSet;
39import java.util.TreeSet;
40import java.util.concurrent.ConcurrentHashMap;
41import java.util.function.BiFunction;
42import java.util.stream.Collectors;
43
44import javax.imageio.ImageIO;
45import javax.swing.ListSelectionModel;
46import javax.xml.namespace.QName;
47import javax.xml.stream.XMLStreamException;
48import javax.xml.stream.XMLStreamReader;
49
50import org.openstreetmap.gui.jmapviewer.Coordinate;
51import org.openstreetmap.gui.jmapviewer.Projected;
52import org.openstreetmap.gui.jmapviewer.Tile;
53import org.openstreetmap.gui.jmapviewer.TileRange;
54import org.openstreetmap.gui.jmapviewer.TileXY;
55import org.openstreetmap.gui.jmapviewer.interfaces.ICoordinate;
56import org.openstreetmap.gui.jmapviewer.interfaces.IProjected;
57import org.openstreetmap.gui.jmapviewer.interfaces.TemplatedTileSource;
58import org.openstreetmap.gui.jmapviewer.tilesources.AbstractTMSTileSource;
59import org.openstreetmap.josm.data.ProjectionBounds;
60import org.openstreetmap.josm.data.coor.EastNorth;
61import org.openstreetmap.josm.data.coor.LatLon;
62import org.openstreetmap.josm.data.imagery.GetCapabilitiesParseHelper.TransferMode;
63import org.openstreetmap.josm.data.imagery.ImageryInfo.ImageryType;
64import org.openstreetmap.josm.data.osm.BBox;
65import org.openstreetmap.josm.data.projection.Projection;
66import org.openstreetmap.josm.data.projection.ProjectionRegistry;
67import org.openstreetmap.josm.data.projection.Projections;
68import org.openstreetmap.josm.gui.ExtendedDialog;
69import org.openstreetmap.josm.gui.MainApplication;
70import org.openstreetmap.josm.gui.layer.NativeScaleLayer.ScaleList;
71import org.openstreetmap.josm.gui.layer.imagery.WMTSLayerSelection;
72import org.openstreetmap.josm.io.CachedFile;
73import org.openstreetmap.josm.spi.preferences.Config;
74import org.openstreetmap.josm.tools.CheckParameterUtil;
75import org.openstreetmap.josm.tools.Logging;
76
77/**
78 * Tile Source handling WMTS providers
79 *
80 * @author Wiktor Niesiobędzki
81 * @since 8526
82 */
83public class WMTSTileSource extends AbstractTMSTileSource implements TemplatedTileSource {
84 /**
85 * WMTS namespace address
86 */
87 public static final String WMTS_NS_URL = "http://www.opengis.net/wmts/1.0";
88
89 // CHECKSTYLE.OFF: SingleSpaceSeparator
90 private static final QName QN_CONTENTS = new QName(WMTS_NS_URL, "Contents");
91 private static final QName QN_DEFAULT = new QName(WMTS_NS_URL, "Default");
92 private static final QName QN_DIMENSION = new QName(WMTS_NS_URL, "Dimension");
93 private static final QName QN_FORMAT = new QName(WMTS_NS_URL, "Format");
94 private static final QName QN_LAYER = new QName(WMTS_NS_URL, "Layer");
95 private static final QName QN_MATRIX_WIDTH = new QName(WMTS_NS_URL, "MatrixWidth");
96 private static final QName QN_MATRIX_HEIGHT = new QName(WMTS_NS_URL, "MatrixHeight");
97 private static final QName QN_RESOURCE_URL = new QName(WMTS_NS_URL, "ResourceURL");
98 private static final QName QN_SCALE_DENOMINATOR = new QName(WMTS_NS_URL, "ScaleDenominator");
99 private static final QName QN_STYLE = new QName(WMTS_NS_URL, "Style");
100 private static final QName QN_TILEMATRIX = new QName(WMTS_NS_URL, "TileMatrix");
101 private static final QName QN_TILEMATRIXSET = new QName(WMTS_NS_URL, "TileMatrixSet");
102 private static final QName QN_TILEMATRIX_SET_LINK = new QName(WMTS_NS_URL, "TileMatrixSetLink");
103 private static final QName QN_TILE_WIDTH = new QName(WMTS_NS_URL, "TileWidth");
104 private static final QName QN_TILE_HEIGHT = new QName(WMTS_NS_URL, "TileHeight");
105 private static final QName QN_TOPLEFT_CORNER = new QName(WMTS_NS_URL, "TopLeftCorner");
106 private static final QName QN_VALUE = new QName(WMTS_NS_URL, "Value");
107 // CHECKSTYLE.ON: SingleSpaceSeparator
108
109 private static final String URL_GET_ENCODING_PARAMS = "SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER={layer}&STYLE={style}&"
110 + "FORMAT={format}&tileMatrixSet={TileMatrixSet}&tileMatrix={TileMatrix}&tileRow={TileRow}&tileCol={TileCol}";
111
112 private int cachedTileSize = -1;
113
114 private static final class TileMatrix {
115 private String identifier;
116 private double scaleDenominator;
117 private EastNorth topLeftCorner;
118 private int tileWidth;
119 private int tileHeight;
120 private int matrixWidth = -1;
121 private int matrixHeight = -1;
122 }
123
124 private static final class TileMatrixSetBuilder {
125 // sorted by zoom level
126 SortedSet<TileMatrix> tileMatrix = new TreeSet<>((o1, o2) -> -1 * Double.compare(o1.scaleDenominator, o2.scaleDenominator));
127 private String crs;
128 private String identifier;
129
130 TileMatrixSet build() {
131 return new TileMatrixSet(this);
132 }
133 }
134
135 /**
136 * class representing WMTS TileMatrixSet
137 * This connects projection and TileMatrix (how the map is divided in tiles)
138 * @since 13733
139 */
140 public static class TileMatrixSet {
141
142 private final List<TileMatrix> tileMatrix;
143 private final String crs;
144 private final String identifier;
145
146 TileMatrixSet(TileMatrixSet tileMatrixSet) {
147 if (tileMatrixSet != null) {
148 tileMatrix = new ArrayList<>(tileMatrixSet.tileMatrix);
149 crs = tileMatrixSet.crs;
150 identifier = tileMatrixSet.identifier;
151 } else {
152 tileMatrix = Collections.emptyList();
153 crs = null;
154 identifier = null;
155 }
156 }
157
158 TileMatrixSet(TileMatrixSetBuilder builder) {
159 tileMatrix = new ArrayList<>(builder.tileMatrix);
160 crs = builder.crs;
161 identifier = builder.identifier;
162 }
163
164 @Override
165 public String toString() {
166 return "TileMatrixSet [crs=" + crs + ", identifier=" + identifier + ']';
167 }
168
169 /**
170 * Returns identifier of this TileMatrixSet.
171 * @return identifier of this TileMatrixSet
172 */
173 public String getIdentifier() {
174 return identifier;
175 }
176
177 /**
178 * Returns projection of this tileMatrix.
179 * @return projection of this tileMatrix
180 */
181 public String getCrs() {
182 return crs;
183 }
184
185 /**
186 * Returns tile matrix max zoom. Assumes first zoom starts at 0, with continuous zoom levels.
187 * @return tile matrix max zoom
188 * @since 15409
189 */
190 public int getMaxZoom() {
191 return tileMatrix.size() - 1;
192 }
193 }
194
195 private static final class Dimension {
196 private String identifier;
197 private String defaultValue;
198 private final List<String> values = new ArrayList<>();
199 }
200
201 /**
202 * Class representing WMTS Layer information
203 * @since 13733
204 */
205 public static class Layer {
206 private String format;
207 private String identifier;
208 private String title;
209 private TileMatrixSet tileMatrixSet;
210 private String baseUrl;
211 private String style;
212 private BBox bbox;
213 private final Collection<String> tileMatrixSetLinks = new ArrayList<>();
214 private final Collection<Dimension> dimensions = new ArrayList<>();
215
216 Layer(Layer l) {
217 Objects.requireNonNull(l);
218 format = l.format;
219 identifier = l.identifier;
220 title = l.title;
221 baseUrl = l.baseUrl;
222 style = l.style;
223 bbox = l.bbox;
224 tileMatrixSet = new TileMatrixSet(l.tileMatrixSet);
225 dimensions.addAll(l.dimensions);
226 }
227
228 Layer() {
229 }
230
231 /**
232 * Get title of the layer for user display.
233 * <p>
234 * This is either the content of the Title element (if available) or
235 * the layer identifier (as fallback)
236 * @return title of the layer for user display
237 */
238 public String getUserTitle() {
239 return title != null ? title : identifier;
240 }
241
242 @Override
243 public String toString() {
244 return "Layer [identifier=" + identifier + ", title=" + title + ", tileMatrixSet="
245 + tileMatrixSet + ", baseUrl=" + baseUrl + ", style=" + style + ']';
246 }
247
248 /**
249 * Returns identifier of this layer.
250 * @return identifier of this layer
251 */
252 public String getIdentifier() {
253 return identifier;
254 }
255
256 /**
257 * Returns style of this layer.
258 * @return style of this layer
259 */
260 public String getStyle() {
261 return style;
262 }
263
264 /**
265 * Returns tileMatrixSet of this layer.
266 * @return tileMatrixSet of this layer
267 */
268 public TileMatrixSet getTileMatrixSet() {
269 return tileMatrixSet;
270 }
271
272 /**
273 * Returns layer max zoom.
274 * @return layer max zoom
275 * @since 15409
276 */
277 public int getMaxZoom() {
278 return tileMatrixSet != null ? tileMatrixSet.getMaxZoom() : 0;
279 }
280
281 /**
282 * Returns the WGS84 bounding box.
283 * @return WGS84 bounding box
284 * @since 15410
285 */
286 public BBox getBbox() {
287 return bbox;
288 }
289 }
290
291 /**
292 * Exception thrown when parser doesn't find expected information in GetCapabilities document
293 * @since 13733
294 */
295 public static class WMTSGetCapabilitiesException extends Exception {
296
297 /**
298 * Create WMTS exception
299 * @param cause description of cause
300 */
301 public WMTSGetCapabilitiesException(String cause) {
302 super(cause);
303 }
304
305 /**
306 * Create WMTS exception
307 * @param cause description of cause
308 * @param t nested exception
309 */
310 public WMTSGetCapabilitiesException(String cause, Throwable t) {
311 super(cause, t);
312 }
313 }
314
315 private static final class SelectLayerDialog extends ExtendedDialog {
316 private final WMTSLayerSelection list;
317
318 SelectLayerDialog(Collection<Layer> layers) {
319 super(MainApplication.getMainFrame(), tr("Select WMTS layer"), tr("Add layers"), tr("Cancel"));
320 this.list = new WMTSLayerSelection(groupLayersByNameAndTileMatrixSet(layers));
321 setContent(list);
322 }
323
324 @Override
325 public void setupDialog() {
326 super.setupDialog();
327 buttons.get(0).setEnabled(false);
328 ListSelectionModel selectionModel = list.getTable().getSelectionModel();
329 selectionModel.addListSelectionListener(e -> buttons.get(0).setEnabled(!selectionModel.isSelectionEmpty()));
330 }
331
332 public DefaultLayer getSelectedLayer() {
333 Layer selectedLayer = list.getSelectedLayer();
334 return selectedLayer == null ? null :
335 new DefaultLayer(ImageryType.WMTS, selectedLayer.identifier, selectedLayer.style, selectedLayer.tileMatrixSet.identifier);
336 }
337 }
338
339 private final Map<String, String> headers = new ConcurrentHashMap<>();
340 private final Collection<Layer> layers;
341 private Layer currentLayer;
342 private TileMatrixSet currentTileMatrixSet;
343 private double crsScale;
344 private final TransferMode transferMode;
345
346 private ScaleList nativeScaleList;
347
348 private final DefaultLayer defaultLayer;
349
350 private Projection tileProjection;
351
352 /**
353 * Creates a tile source based on imagery info
354 * @param info imagery info
355 * @throws IOException if any I/O error occurs
356 * @throws WMTSGetCapabilitiesException when document didn't contain any layers
357 * @throws IllegalArgumentException if any other error happens for the given imagery info
358 */
359 public WMTSTileSource(ImageryInfo info) throws IOException, WMTSGetCapabilitiesException {
360 super(info);
361 CheckParameterUtil.ensureThat(info.getDefaultLayers().size() < 2, "At most 1 default layer for WMTS is supported");
362 this.headers.putAll(info.getCustomHttpHeaders());
363 this.baseUrl = GetCapabilitiesParseHelper.normalizeCapabilitiesUrl(
364 ImageryPatterns.handleApiKeyTemplate(info.getId(), ImageryPatterns.handleHeaderTemplate(info.getUrl(), headers)));
365 WMTSCapabilities capabilities = getCapabilities(baseUrl, headers);
366 this.layers = capabilities.getLayers();
367 this.baseUrl = capabilities.getBaseUrl();
368 this.transferMode = capabilities.getTransferMode();
369 if (info.getDefaultLayers().isEmpty()) {
370 Logging.warn(tr("No default layer selected, choosing first layer."));
371 if (!layers.isEmpty()) {
372 Layer first = layers.iterator().next();
373 // If max zoom lower than expected, try to find a better layer
374 final int maxZoom = info.getMaxZoom();
375 if (first.getMaxZoom() < maxZoom) {
376 first = layers.stream().filter(l -> l.getMaxZoom() >= maxZoom).findFirst().orElse(first);
377 }
378 // If center of josm bbox not in layer bbox, try to find a better layer
379 if (info.getBounds() != null && first.getBbox() != null) {
380 LatLon center = info.getBounds().getCenter();
381 if (!first.getBbox().bounds(center)) {
382 final Layer ffirst = first;
383 first = layers.stream()
384 .filter(l -> l.getMaxZoom() >= maxZoom && l.getBbox() != null && l.getBbox().bounds(center)).findFirst()
385 .orElseGet(() -> layers.stream().filter(l -> l.getBbox() != null && l.getBbox().bounds(center)).findFirst()
386 .orElse(ffirst));
387 }
388 }
389 this.defaultLayer = new DefaultLayer(info.getImageryType(), first.identifier, first.style, first.tileMatrixSet.identifier);
390 } else {
391 this.defaultLayer = null;
392 }
393 } else {
394 this.defaultLayer = info.getDefaultLayers().get(0);
395 }
396 if (this.layers.isEmpty())
397 throw new IllegalArgumentException(tr("No layers defined by getCapabilities document: {0}", info.getUrl()));
398 }
399
400 /**
401 * Creates a tile source based on imagery info and initializes it with given projection.
402 * @param info imagery info
403 * @param projection projection to be used by this TileSource
404 * @throws IOException if any I/O error occurs
405 * @throws WMTSGetCapabilitiesException when document didn't contain any layers
406 * @throws IllegalArgumentException if any other error happens for the given imagery info
407 * @since 14507
408 */
409 public WMTSTileSource(ImageryInfo info, Projection projection) throws IOException, WMTSGetCapabilitiesException {
410 this(info);
411 initProjection(projection);
412 }
413
414 /**
415 * Creates a dialog based on this tile source with all available layers and returns the name of selected layer
416 * @return Name of selected layer
417 */
418 public DefaultLayer userSelectLayer() {
419 Map<String, List<Layer>> layerById = layers.stream().collect(
420 Collectors.groupingBy(x -> x.identifier));
421 if (layerById.size() == 1) { // only one layer
422 List<Layer> ls = layerById.entrySet().iterator().next().getValue()
423 .stream().filter(
424 u -> u.tileMatrixSet.crs.equals(ProjectionRegistry.getProjection().toCode()))
425 .collect(Collectors.toList());
426 if (ls.size() == 1) {
427 // only one tile matrix set with matching projection - no point in asking
428 Layer selectedLayer = ls.get(0);
429 return new DefaultLayer(ImageryType.WMTS, selectedLayer.identifier, selectedLayer.style, selectedLayer.tileMatrixSet.identifier);
430 }
431 }
432
433 final SelectLayerDialog layerSelection = new SelectLayerDialog(layers);
434 if (layerSelection.showDialog().getValue() == 1) {
435 return layerSelection.getSelectedLayer();
436 }
437 return null;
438 }
439
440 /**
441 * Call remote server and parse response to WMTSCapabilities object
442 *
443 * @param url of the getCapabilities document
444 * @param headers HTTP headers to set when calling getCapabilities url
445 * @return capabilities
446 * @throws IOException in case of any I/O error
447 * @throws WMTSGetCapabilitiesException when document didn't contain any layers
448 * @throws IllegalArgumentException in case of any other error
449 */
450 public static WMTSCapabilities getCapabilities(String url, Map<String, String> headers) throws IOException, WMTSGetCapabilitiesException {
451 try (CachedFile cf = new CachedFile(url); InputStream in = cf.setHttpHeaders(headers).
452 setMaxAge(Config.getPref().getLong("wmts.capabilities.cache.max_age", 7 * CachedFile.DAYS)).
453 setCachingStrategy(CachedFile.CachingStrategy.IfModifiedSince).
454 getInputStream()) {
455 byte[] data = in.readAllBytes();
456 if (data.length == 0) {
457 cf.clear();
458 throw new IllegalArgumentException("Could not read data from: " + url);
459 }
460
461 try {
462 XMLStreamReader reader = GetCapabilitiesParseHelper.getReader(new ByteArrayInputStream(data));
463 WMTSCapabilities ret = null;
464 Collection<Layer> layers = null;
465 for (int event = reader.getEventType(); reader.hasNext(); event = reader.next()) {
466 if (event == START_ELEMENT) {
467 QName qName = reader.getName();
468 if (QN_OWS_OPERATIONS_METADATA.equals(qName)) {
469 ret = parseOperationMetadata(reader);
470 } else if (QN_CONTENTS.equals(qName)) {
471 layers = parseContents(reader);
472 }
473 }
474 }
475 if (ret == null) {
476 /*
477 * see #12168 - create dummy operation metadata - not all WMTS services provide this information
478 *
479 * WMTS Standard:
480 * > Resource oriented architecture style HTTP encodings SHALL not be described in the OperationsMetadata section.
481 *
482 * And OperationMetada is not mandatory element. So REST mode is justifiable
483 */
484 ret = new WMTSCapabilities(url, TransferMode.REST);
485 }
486 if (layers == null) {
487 throw new WMTSGetCapabilitiesException(tr("WMTS Capabilities document did not contain layers in url: {0}", url));
488 }
489 ret.addLayers(layers);
490 return ret;
491 } catch (XMLStreamException e) {
492 cf.clear();
493 Logging.warn(new String(data, StandardCharsets.UTF_8));
494 throw new WMTSGetCapabilitiesException(tr("Error during parsing of WMTS Capabilities document: {0}", e.getMessage()), e);
495 }
496 } catch (InvalidPathException e) {
497 throw new WMTSGetCapabilitiesException(tr("Invalid path for GetCapabilities document: {0}", e.getMessage()), e);
498 }
499 }
500
501 /**
502 * Parse Contents tag. Returns when reader reaches Contents closing tag
503 *
504 * @param reader StAX reader instance
505 * @return collection of layers within contents with properly linked TileMatrixSets
506 * @throws XMLStreamException See {@link XMLStreamReader}
507 */
508 private static Collection<Layer> parseContents(XMLStreamReader reader) throws XMLStreamException {
509 Map<String, TileMatrixSet> matrixSetById = new HashMap<>();
510 Collection<Layer> layers = new ArrayList<>();
511 for (int event = reader.getEventType();
512 reader.hasNext() && !(event == END_ELEMENT && QN_CONTENTS.equals(reader.getName()));
513 event = reader.next()) {
514 if (event == START_ELEMENT) {
515 QName qName = reader.getName();
516 if (QN_LAYER.equals(qName)) {
517 Layer l = parseLayer(reader);
518 if (l != null) {
519 layers.add(l);
520 }
521 } else if (QN_TILEMATRIXSET.equals(qName)) {
522 TileMatrixSet entry = parseTileMatrixSet(reader);
523 matrixSetById.put(entry.identifier, entry);
524 }
525 }
526 }
527 Collection<Layer> ret = new ArrayList<>();
528 // link layers to matrix sets
529 for (Layer l: layers) {
530 for (String tileMatrixId: l.tileMatrixSetLinks) {
531 Layer newLayer = new Layer(l); // create a new layer object for each tile matrix set supported
532 newLayer.tileMatrixSet = matrixSetById.get(tileMatrixId);
533 ret.add(newLayer);
534 }
535 }
536 return ret;
537 }
538
539 /**
540 * Parse Layer tag. Returns when reader will reach Layer closing tag
541 *
542 * @param reader StAX reader instance
543 * @return Layer object, with tileMatrixSetLinks and no tileMatrixSet attribute set.
544 * @throws XMLStreamException See {@link XMLStreamReader}
545 */
546 private static Layer parseLayer(XMLStreamReader reader) throws XMLStreamException {
547 Layer layer = new Layer();
548 Deque<QName> tagStack = new LinkedList<>();
549 List<String> supportedMimeTypes = new ArrayList<>(Arrays.asList(ImageIO.getReaderMIMETypes()));
550 supportedMimeTypes.add("image/jpgpng"); // used by ESRI
551 supportedMimeTypes.add("image/png8"); // used by geoserver
552 supportedMimeTypes.add("image/vnd.jpeg-png"); // used by geoserver
553 supportedMimeTypes.add("image/vnd.jpeg-png8"); // used by geoserver
554 supportedMimeTypes.add("image/png; mode=8bit"); // used by MapServer
555 if (supportedMimeTypes.contains("image/jpeg")) {
556 supportedMimeTypes.add("image/jpg"); // sometimes misspelled by Arcgis
557 }
558 Collection<String> unsupportedFormats = new ArrayList<>();
559
560 for (int event = reader.getEventType();
561 reader.hasNext() && !(event == END_ELEMENT && QN_LAYER.equals(reader.getName()));
562 event = reader.next()) {
563 if (event == START_ELEMENT) {
564 QName qName = reader.getName();
565 tagStack.push(qName);
566 if (tagStack.size() == 2) {
567 if (QN_FORMAT.equals(qName)) {
568 String format = reader.getElementText();
569 if (supportedMimeTypes.contains(format)) {
570 layer.format = format;
571 } else {
572 unsupportedFormats.add(format);
573 }
574 } else if (QN_OWS_IDENTIFIER.equals(qName)) {
575 layer.identifier = reader.getElementText();
576 } else if (QN_OWS_TITLE.equals(qName)) {
577 layer.title = reader.getElementText();
578 } else if (QN_RESOURCE_URL.equals(qName) &&
579 "tile".equals(reader.getAttributeValue("", "resourceType"))) {
580 layer.baseUrl = reader.getAttributeValue("", "template");
581 } else if (QN_STYLE.equals(qName) &&
582 "true".equals(reader.getAttributeValue("", "isDefault"))) {
583 if (GetCapabilitiesParseHelper.moveReaderToTag(reader, QN_OWS_IDENTIFIER)) {
584 layer.style = reader.getElementText();
585 tagStack.push(reader.getName()); // keep tagStack in sync
586 }
587 } else if (QN_DIMENSION.equals(qName)) {
588 layer.dimensions.add(parseDimension(reader));
589 } else if (QN_TILEMATRIX_SET_LINK.equals(qName)) {
590 layer.tileMatrixSetLinks.add(parseTileMatrixSetLink(reader));
591 } else if (QN_OWS_WGS84_BOUNDING_BOX.equals(qName)) {
592 layer.bbox = parseBoundingBox(reader);
593 } else {
594 GetCapabilitiesParseHelper.moveReaderToEndCurrentTag(reader);
595 }
596 }
597 }
598 // need to get event type from reader, as parsing might have change position of reader
599 if (reader.getEventType() == END_ELEMENT) {
600 QName start = tagStack.pop();
601 if (!start.equals(reader.getName())) {
602 throw new IllegalStateException(tr("WMTS Parser error - start element {0} has different name than end element {2}",
603 start, reader.getName()));
604 }
605 }
606 }
607 if (layer.style == null) {
608 layer.style = "";
609 }
610 if (layer.format == null) {
611 // no format found - it's mandatory parameter - can't use this layer
612 Logging.warn(tr("Can''t use layer {0} because no supported formats were found. Layer is available in formats: {1}",
613 layer.getUserTitle(),
614 String.join(", ", unsupportedFormats)));
615 return null;
616 }
617 // Java has issues if spaces are not URL encoded. Ensure that we URL encode the spaces.
618 if (layer.format.contains(" ")) {
619 layer.format = layer.format.replace(" ", "%20");
620 }
621 return layer;
622 }
623
624 /**
625 * Gets Dimension value. Returns when reader is on Dimension closing tag
626 *
627 * @param reader StAX reader instance
628 * @return dimension
629 * @throws XMLStreamException See {@link XMLStreamReader}
630 */
631 private static Dimension parseDimension(XMLStreamReader reader) throws XMLStreamException {
632 Dimension ret = new Dimension();
633 for (int event = reader.getEventType();
634 reader.hasNext() && !(event == END_ELEMENT && QN_DIMENSION.equals(reader.getName()));
635 event = reader.next()) {
636 if (event == START_ELEMENT) {
637 QName qName = reader.getName();
638 if (QN_OWS_IDENTIFIER.equals(qName)) {
639 ret.identifier = reader.getElementText();
640 } else if (QN_DEFAULT.equals(qName)) {
641 ret.defaultValue = reader.getElementText();
642 } else if (QN_VALUE.equals(qName)) {
643 ret.values.add(reader.getElementText());
644 }
645 }
646 }
647 return ret;
648 }
649
650 /**
651 * Gets TileMatrixSetLink value. Returns when reader is on TileMatrixSetLink closing tag
652 *
653 * @param reader StAX reader instance
654 * @return TileMatrixSetLink identifier
655 * @throws XMLStreamException See {@link XMLStreamReader}
656 */
657 private static String parseTileMatrixSetLink(XMLStreamReader reader) throws XMLStreamException {
658 String ret = null;
659 for (int event = reader.getEventType();
660 reader.hasNext() && !(event == END_ELEMENT && QN_TILEMATRIX_SET_LINK.equals(reader.getName()));
661 event = reader.next()) {
662 if (event == START_ELEMENT && QN_TILEMATRIXSET.equals(reader.getName())) {
663 ret = reader.getElementText();
664 }
665 }
666 return ret;
667 }
668
669 /**
670 * Parses TileMatrixSet section. Returns when reader is on TileMatrixSet closing tag
671 * @param reader StAX reader instance
672 * @return TileMatrixSet object
673 * @throws XMLStreamException See {@link XMLStreamReader}
674 */
675 private static TileMatrixSet parseTileMatrixSet(XMLStreamReader reader) throws XMLStreamException {
676 TileMatrixSetBuilder matrixSet = new TileMatrixSetBuilder();
677 for (int event = reader.getEventType();
678 reader.hasNext() && !(event == END_ELEMENT && QN_TILEMATRIXSET.equals(reader.getName()));
679 event = reader.next()) {
680 if (event == START_ELEMENT) {
681 QName qName = reader.getName();
682 if (QN_OWS_IDENTIFIER.equals(qName)) {
683 matrixSet.identifier = reader.getElementText();
684 } else if (QN_OWS_SUPPORTED_CRS.equals(qName)) {
685 matrixSet.crs = GetCapabilitiesParseHelper.crsToCode(reader.getElementText());
686 } else if (QN_TILEMATRIX.equals(qName)) {
687 matrixSet.tileMatrix.add(parseTileMatrix(reader, matrixSet.crs));
688 }
689 }
690 }
691 return matrixSet.build();
692 }
693
694 /**
695 * Parses TileMatrix section. Returns when reader is on TileMatrix closing tag.
696 * @param reader StAX reader instance
697 * @param matrixCrs projection used by this matrix
698 * @return TileMatrix object
699 * @throws XMLStreamException See {@link XMLStreamReader}
700 */
701 private static TileMatrix parseTileMatrix(XMLStreamReader reader, String matrixCrs) throws XMLStreamException {
702 Projection matrixProj = Optional.ofNullable(Projections.getProjectionByCode(matrixCrs))
703 .orElseGet(ProjectionRegistry::getProjection); // use current projection if none found. Maybe user is using custom string
704 TileMatrix ret = new TileMatrix();
705 for (int event = reader.getEventType();
706 reader.hasNext() && !(event == END_ELEMENT && QN_TILEMATRIX.equals(reader.getName()));
707 event = reader.next()) {
708 if (event == START_ELEMENT) {
709 QName qName = reader.getName();
710 if (QN_OWS_IDENTIFIER.equals(qName)) {
711 ret.identifier = reader.getElementText();
712 } else if (QN_SCALE_DENOMINATOR.equals(qName)) {
713 ret.scaleDenominator = Double.parseDouble(reader.getElementText());
714 } else if (QN_TOPLEFT_CORNER.equals(qName)) {
715 ret.topLeftCorner = parseEastNorth(reader.getElementText(), matrixProj.switchXY());
716 } else if (QN_TILE_HEIGHT.equals(qName)) {
717 ret.tileHeight = Integer.parseInt(reader.getElementText());
718 } else if (QN_TILE_WIDTH.equals(qName)) {
719 ret.tileWidth = Integer.parseInt(reader.getElementText());
720 } else if (QN_MATRIX_HEIGHT.equals(qName)) {
721 ret.matrixHeight = Integer.parseInt(reader.getElementText());
722 } else if (QN_MATRIX_WIDTH.equals(qName)) {
723 ret.matrixWidth = Integer.parseInt(reader.getElementText());
724 }
725 }
726 }
727 if (ret.tileHeight != ret.tileWidth) {
728 throw new AssertionError(tr("Only square tiles are supported. {0}x{1} returned by server for TileMatrix identifier {2}",
729 ret.tileHeight, ret.tileWidth, ret.identifier));
730 }
731 return ret;
732 }
733
734 private static <T> T parseCoor(String coor, boolean switchXY, BiFunction<String, String, T> function) {
735 String[] parts = coor.split(" ", -1);
736 if (switchXY) {
737 return function.apply(parts[1], parts[0]);
738 } else {
739 return function.apply(parts[0], parts[1]);
740 }
741 }
742
743 private static EastNorth parseEastNorth(String coor, boolean switchXY) {
744 return parseCoor(coor, switchXY, (e, n) -> new EastNorth(Double.parseDouble(e), Double.parseDouble(n)));
745 }
746
747 private static LatLon parseLatLon(String coor, boolean switchXY) {
748 return parseCoor(coor, switchXY, (lon, lat) -> new LatLon(Double.parseDouble(lat), Double.parseDouble(lon)));
749 }
750
751 /**
752 * Parses WGS84BoundingBox section. Returns when reader is on WGS84BoundingBox closing tag.
753 * @param reader StAX reader instance
754 * @return WGS84 bounding box
755 * @throws XMLStreamException See {@link XMLStreamReader}
756 */
757 private static BBox parseBoundingBox(XMLStreamReader reader) throws XMLStreamException {
758 LatLon lowerCorner = null;
759 LatLon upperCorner = null;
760 for (int event = reader.getEventType();
761 reader.hasNext() && !(event == END_ELEMENT && QN_OWS_WGS84_BOUNDING_BOX.equals(reader.getName()));
762 event = reader.next()) {
763 if (event == START_ELEMENT) {
764 QName qName = reader.getName();
765 if (QN_OWS_LOWER_CORNER.equals(qName)) {
766 lowerCorner = parseLatLon(reader.getElementText(), false);
767 } else if (QN_OWS_UPPER_CORNER.equals(qName)) {
768 upperCorner = parseLatLon(reader.getElementText(), false);
769 }
770 }
771 }
772 if (lowerCorner != null && upperCorner != null) {
773 return new BBox(lowerCorner, upperCorner);
774 }
775 return null;
776 }
777
778 /**
779 * Parses OperationMetadata section. Returns when reader is on OperationsMetadata closing tag.
780 * return WMTSCapabilities with baseUrl and transferMode
781 *
782 * @param reader StAX reader instance
783 * @return WMTSCapabilities with baseUrl and transferMode set
784 * @throws XMLStreamException See {@link XMLStreamReader}
785 */
786 private static WMTSCapabilities parseOperationMetadata(XMLStreamReader reader) throws XMLStreamException {
787 for (int event = reader.getEventType();
788 reader.hasNext() && !(event == END_ELEMENT && QN_OWS_OPERATIONS_METADATA.equals(reader.getName()));
789 event = reader.next()) {
790 if (event == START_ELEMENT &&
791 QN_OWS_OPERATION.equals(reader.getName()) &&
792 "GetTile".equals(reader.getAttributeValue("", "name")) &&
793 GetCapabilitiesParseHelper.moveReaderToTag(reader, QN_OWS_DCP, QN_OWS_HTTP, QN_OWS_GET)) {
794 return new WMTSCapabilities(
795 reader.getAttributeValue(GetCapabilitiesParseHelper.XLINK_NS_URL, "href"),
796 GetCapabilitiesParseHelper.getTransferMode(reader)
797 );
798 }
799 }
800 return null;
801 }
802
803 /**
804 * Initializes projection for this TileSource with projection
805 * @param proj projection to be used by this TileSource
806 */
807 public void initProjection(Projection proj) {
808 if (proj.equals(tileProjection))
809 return;
810 List<Layer> matchingLayers = layers.stream().filter(
811 l -> l.identifier.equals(defaultLayer.getLayerName()) && l.tileMatrixSet.crs.equals(proj.toCode()))
812 .collect(Collectors.toList());
813 if (matchingLayers.size() > 1) {
814 this.currentLayer = matchingLayers.stream().filter(
815 l -> l.tileMatrixSet.identifier.equals(defaultLayer.getTileMatrixSet()))
816 .findFirst().orElse(matchingLayers.get(0));
817 this.tileProjection = proj;
818 } else if (matchingLayers.size() == 1) {
819 this.currentLayer = matchingLayers.get(0);
820 this.tileProjection = proj;
821 } else {
822 // no tile matrix sets with current projection
823 if (this.currentLayer == null) {
824 this.tileProjection = null;
825 for (Layer layer : layers) {
826 if (!layer.identifier.equals(defaultLayer.getLayerName())) {
827 continue;
828 }
829 Projection pr = Projections.getProjectionByCode(layer.tileMatrixSet.crs);
830 if (pr != null) {
831 this.currentLayer = layer;
832 this.tileProjection = pr;
833 break;
834 }
835 }
836 if (this.currentLayer == null)
837 throw new IllegalArgumentException(
838 layers.stream().map(l -> l.tileMatrixSet).collect(Collectors.toList()).toString());
839 } // else: keep currentLayer and tileProjection as is
840 }
841 if (this.currentLayer != null) {
842 this.currentTileMatrixSet = this.currentLayer.tileMatrixSet;
843 Collection<Double> scales = currentTileMatrixSet.tileMatrix.stream()
844 .map(tileMatrix -> tileMatrix.scaleDenominator * 0.28e-03)
845 .collect(Collectors.toList());
846 this.nativeScaleList = new ScaleList(scales);
847 }
848 this.crsScale = getTileSize() * 0.28e-03 / this.tileProjection.getMetersPerUnit();
849 }
850
851 @Override
852 public int getTileSize() {
853 if (cachedTileSize > 0) {
854 return cachedTileSize;
855 }
856 if (currentTileMatrixSet != null) {
857 // no support for non-square tiles (tileHeight != tileWidth)
858 // and for different tile sizes at different zoom levels
859 cachedTileSize = currentTileMatrixSet.tileMatrix.get(0).tileHeight;
860 return cachedTileSize;
861 }
862 // Fallback to default mercator tile size. Maybe it will work
863 Logging.warn("WMTS: Could not determine tile size. Using default tile size of: {0}", getDefaultTileSize());
864 return getDefaultTileSize();
865 }
866
867 @Override
868 public String getTileUrl(int zoom, int tilex, int tiley) {
869 if (currentLayer == null) {
870 return "";
871 }
872
873 String url;
874 if (currentLayer.baseUrl != null && transferMode == null) {
875 url = currentLayer.baseUrl;
876 } else {
877 switch (transferMode) {
878 case KVP:
879 url = baseUrl + URL_GET_ENCODING_PARAMS;
880 break;
881 case REST:
882 url = currentLayer.baseUrl;
883 break;
884 default:
885 url = "";
886 break;
887 }
888 }
889
890 TileMatrix tileMatrix = getTileMatrix(zoom);
891
892 if (tileMatrix == null) {
893 return ""; // no matrix, probably unsupported CRS selected.
894 }
895
896 url = url.replace("{layer}", this.currentLayer.identifier)
897 .replace("{format}", this.currentLayer.format)
898 .replace("{TileMatrixSet}", this.currentTileMatrixSet.identifier)
899 .replace("{TileMatrix}", tileMatrix.identifier)
900 .replace("{TileRow}", Integer.toString(tiley))
901 .replace("{TileCol}", Integer.toString(tilex))
902 .replaceAll("(?i)\\{style}", this.currentLayer.style);
903
904 for (Dimension d : currentLayer.dimensions) {
905 url = url.replaceAll("(?i)\\{"+d.identifier+"}", d.defaultValue);
906 }
907
908 return url;
909 }
910
911 /**
912 * Returns TileMatrix that's working on given zoom level
913 * @param zoom zoom level
914 * @return TileMatrix that's working on this zoom level
915 */
916 private TileMatrix getTileMatrix(int zoom) {
917 if (zoom > getMaxZoom()) {
918 return null;
919 }
920 if (zoom < 0) {
921 return null;
922 }
923 return this.currentTileMatrixSet.tileMatrix.get(zoom);
924 }
925
926 @Override
927 public double getDistance(double lat1, double lon1, double lat2, double lon2) {
928 throw new UnsupportedOperationException("Not implemented");
929 }
930
931 @Override
932 public ICoordinate tileXYToLatLon(int x, int y, int zoom) {
933 TileMatrix matrix = getTileMatrix(zoom);
934 if (matrix == null) {
935 return CoordinateConversion.llToCoor(tileProjection.getWorldBoundsLatLon().getCenter());
936 }
937 double scale = matrix.scaleDenominator * this.crsScale;
938 EastNorth ret = new EastNorth(matrix.topLeftCorner.east() + x * scale, matrix.topLeftCorner.north() - y * scale);
939 return CoordinateConversion.llToCoor(tileProjection.eastNorth2latlon(ret));
940 }
941
942 @Override
943 public TileXY latLonToTileXY(double lat, double lon, int zoom) {
944 TileMatrix matrix = getTileMatrix(zoom);
945 if (matrix == null) {
946 return new TileXY(0, 0);
947 }
948
949 EastNorth enPoint = tileProjection.latlon2eastNorth(new LatLon(lat, lon));
950 double scale = matrix.scaleDenominator * this.crsScale;
951 return new TileXY(
952 (enPoint.east() - matrix.topLeftCorner.east()) / scale,
953 (matrix.topLeftCorner.north() - enPoint.north()) / scale
954 );
955 }
956
957 @Override
958 public int getTileXMax(int zoom) {
959 return getTileXMax(zoom, tileProjection);
960 }
961
962 @Override
963 public int getTileYMax(int zoom) {
964 return getTileYMax(zoom, tileProjection);
965 }
966
967 @Override
968 public Point latLonToXY(double lat, double lon, int zoom) {
969 TileMatrix matrix = getTileMatrix(zoom);
970 if (matrix == null) {
971 return new Point(0, 0);
972 }
973 double scale = matrix.scaleDenominator * this.crsScale;
974 EastNorth point = tileProjection.latlon2eastNorth(new LatLon(lat, lon));
975 return new Point(
976 (int) Math.round((point.east() - matrix.topLeftCorner.east()) / scale),
977 (int) Math.round((matrix.topLeftCorner.north() - point.north()) / scale)
978 );
979 }
980
981 @Override
982 public Coordinate xyToLatLon(int x, int y, int zoom) {
983 TileMatrix matrix = getTileMatrix(zoom);
984 if (matrix == null) {
985 return new Coordinate(0, 0);
986 }
987 double scale = matrix.scaleDenominator * this.crsScale;
988 EastNorth ret = new EastNorth(
989 matrix.topLeftCorner.east() + x * scale,
990 matrix.topLeftCorner.north() - y * scale
991 );
992 LatLon ll = tileProjection.eastNorth2latlon(ret);
993 return new Coordinate(ll.lat(), ll.lon());
994 }
995
996 @Override
997 public Map<String, String> getHeaders() {
998 return headers;
999 }
1000
1001 @Override
1002 public int getMaxZoom() {
1003 if (this.currentTileMatrixSet != null) {
1004 return this.currentTileMatrixSet.getMaxZoom();
1005 }
1006 return 0;
1007 }
1008
1009 @Override
1010 public String getTileId(int zoom, int tilex, int tiley) {
1011 return getTileUrl(zoom, tilex, tiley);
1012 }
1013
1014 /**
1015 * Checks if url is acceptable by this Tile Source
1016 * @param url URL to check
1017 */
1018 public static void checkUrl(String url) {
1019 ImageryPatterns.checkWmtsUrlPatterns(url);
1020 }
1021
1022 /**
1023 * Group layers by name and tile matrix set.
1024 * @param layers to be grouped
1025 * @return list with entries - grouping identifier + list of layers
1026 */
1027 public static List<Entry<String, List<Layer>>> groupLayersByNameAndTileMatrixSet(Collection<Layer> layers) {
1028 Map<String, List<Layer>> layerByName = layers.stream().collect(
1029 Collectors.groupingBy(x -> x.identifier + '\u001c' + x.tileMatrixSet.identifier));
1030 return layerByName.entrySet().stream().sorted(Map.Entry.comparingByKey()).collect(Collectors.toList());
1031 }
1032
1033 /**
1034 * Returns set of projection codes that this TileSource supports.
1035 * @return set of projection codes that this TileSource supports
1036 */
1037 public Collection<String> getSupportedProjections() {
1038 return this.layers.stream()
1039 .filter(layer -> currentLayer == null || currentLayer.identifier.equals(layer.identifier))
1040 .map(layer -> layer.tileMatrixSet.crs)
1041 .collect(Collectors.toCollection(LinkedHashSet::new));
1042 }
1043
1044 private int getTileYMax(int zoom, Projection proj) {
1045 TileMatrix matrix = getTileMatrix(zoom);
1046 if (matrix == null) {
1047 return 0;
1048 }
1049
1050 if (matrix.matrixHeight != -1) {
1051 return matrix.matrixHeight;
1052 }
1053
1054 double scale = matrix.scaleDenominator * this.crsScale;
1055 EastNorth min = matrix.topLeftCorner;
1056 EastNorth max = proj.latlon2eastNorth(proj.getWorldBoundsLatLon().getMax());
1057 return (int) Math.ceil(Math.abs(max.north() - min.north()) / scale);
1058 }
1059
1060 private int getTileXMax(int zoom, Projection proj) {
1061 TileMatrix matrix = getTileMatrix(zoom);
1062 if (matrix == null) {
1063 return 0;
1064 }
1065 if (matrix.matrixWidth != -1) {
1066 return matrix.matrixWidth;
1067 }
1068
1069 double scale = matrix.scaleDenominator * this.crsScale;
1070 EastNorth min = matrix.topLeftCorner;
1071 EastNorth max = proj.latlon2eastNorth(proj.getWorldBoundsLatLon().getMax());
1072 return (int) Math.ceil(Math.abs(max.east() - min.east()) / scale);
1073 }
1074
1075 /**
1076 * Get native scales of tile source.
1077 * @return {@link ScaleList} of native scales
1078 */
1079 public ScaleList getNativeScales() {
1080 return nativeScaleList;
1081 }
1082
1083 /**
1084 * Returns the tile projection.
1085 * @return the tile projection
1086 */
1087 public Projection getTileProjection() {
1088 return tileProjection;
1089 }
1090
1091 @Override
1092 public IProjected tileXYtoProjected(int x, int y, int zoom) {
1093 TileMatrix matrix = getTileMatrix(zoom);
1094 if (matrix == null) {
1095 return new Projected(0, 0);
1096 }
1097 double scale = matrix.scaleDenominator * this.crsScale;
1098 return new Projected(
1099 matrix.topLeftCorner.east() + x * scale,
1100 matrix.topLeftCorner.north() - y * scale);
1101 }
1102
1103 @Override
1104 public TileXY projectedToTileXY(IProjected projected, int zoom) {
1105 TileMatrix matrix = getTileMatrix(zoom);
1106 if (matrix == null) {
1107 return new TileXY(0, 0);
1108 }
1109 double scale = matrix.scaleDenominator * this.crsScale;
1110 return new TileXY(
1111 (projected.getEast() - matrix.topLeftCorner.east()) / scale,
1112 -(projected.getNorth() - matrix.topLeftCorner.north()) / scale);
1113 }
1114
1115 private EastNorth tileToEastNorth(int x, int y, int z) {
1116 return CoordinateConversion.projToEn(this.tileXYtoProjected(x, y, z));
1117 }
1118
1119 private ProjectionBounds getTileProjectionBounds(Tile tile) {
1120 ProjectionBounds pb = new ProjectionBounds(tileToEastNorth(tile.getXtile(), tile.getYtile(), tile.getZoom()));
1121 pb.extend(tileToEastNorth(tile.getXtile() + 1, tile.getYtile() + 1, tile.getZoom()));
1122 return pb;
1123 }
1124
1125 @Override
1126 public boolean isInside(Tile inner, Tile outer) {
1127 ProjectionBounds pbInner = getTileProjectionBounds(inner);
1128 ProjectionBounds pbOuter = getTileProjectionBounds(outer);
1129 // a little tolerance, for when inner tile touches the border of the outer tile
1130 double epsilon = 1e-7 * (pbOuter.maxEast - pbOuter.minEast);
1131 return pbOuter.minEast <= pbInner.minEast + epsilon &&
1132 pbOuter.minNorth <= pbInner.minNorth + epsilon &&
1133 pbOuter.maxEast >= pbInner.maxEast - epsilon &&
1134 pbOuter.maxNorth >= pbInner.maxNorth - epsilon;
1135 }
1136
1137 @Override
1138 public TileRange getCoveringTileRange(Tile tile, int newZoom) {
1139 TileMatrix matrixNew = getTileMatrix(newZoom);
1140 if (matrixNew == null) {
1141 return new TileRange(new TileXY(0, 0), new TileXY(0, 0), newZoom);
1142 }
1143 IProjected p0 = tileXYtoProjected(tile.getXtile(), tile.getYtile(), tile.getZoom());
1144 IProjected p1 = tileXYtoProjected(tile.getXtile() + 1, tile.getYtile() + 1, tile.getZoom());
1145 TileXY tMin = projectedToTileXY(p0, newZoom);
1146 TileXY tMax = projectedToTileXY(p1, newZoom);
1147 // shrink the target tile a little, so we don't get neighboring tiles, that
1148 // share an edge, but don't actually cover the target tile
1149 double epsilon = 1e-7 * (tMax.getX() - tMin.getX());
1150 int minX = (int) Math.floor(tMin.getX() + epsilon);
1151 int minY = (int) Math.floor(tMin.getY() + epsilon);
1152 int maxX = (int) Math.ceil(tMax.getX() - epsilon) - 1;
1153 int maxY = (int) Math.ceil(tMax.getY() - epsilon) - 1;
1154 return new TileRange(new TileXY(minX, minY), new TileXY(maxX, maxY), newZoom);
1155 }
1156
1157 @Override
1158 public String getServerCRS() {
1159 return tileProjection != null ? tileProjection.toCode() : null;
1160 }
1161
1162 /**
1163 * Layers that can be used with this tile source
1164 * @return unmodifiable collection of layers available in this tile source
1165 * @since 13879
1166 */
1167 public Collection<Layer> getLayers() {
1168 return Collections.unmodifiableCollection(layers);
1169 }
1170}
Note: See TracBrowser for help on using the repository browser.