source: josm/trunk/src/org/openstreetmap/josm/io/imagery/WMSImagery.java @ 12475

Last change on this file since 12475 was 12475, checked in by Don-vip, 6 weeks ago

see #15012 - checkstyle + javadoc

  • Property svn:eol-style set to native
File size: 18.5 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.io.imagery;
3
4import java.awt.HeadlessException;
5import java.io.IOException;
6import java.io.StringReader;
7import java.net.MalformedURLException;
8import java.net.URL;
9import java.util.ArrayList;
10import java.util.Collection;
11import java.util.Collections;
12import java.util.HashSet;
13import java.util.Iterator;
14import java.util.List;
15import java.util.Locale;
16import java.util.NoSuchElementException;
17import java.util.Set;
18import java.util.regex.Pattern;
19import java.util.stream.Collectors;
20import java.util.stream.Stream;
21import java.util.stream.StreamSupport;
22
23import javax.imageio.ImageIO;
24import javax.xml.parsers.DocumentBuilder;
25import javax.xml.parsers.ParserConfigurationException;
26
27import org.openstreetmap.josm.Main;
28import org.openstreetmap.josm.data.Bounds;
29import org.openstreetmap.josm.data.imagery.ImageryInfo;
30import org.openstreetmap.josm.data.projection.Projections;
31import org.openstreetmap.josm.tools.HttpClient;
32import org.openstreetmap.josm.tools.Utils;
33import org.w3c.dom.Document;
34import org.w3c.dom.Element;
35import org.w3c.dom.Node;
36import org.w3c.dom.NodeList;
37import org.xml.sax.InputSource;
38import org.xml.sax.SAXException;
39
40/**
41 * This class represents the capabilites of a WMS imagery server.
42 */
43public class WMSImagery {
44
45    private static final class ChildIterator implements Iterator<Element> {
46        private Element child;
47
48        ChildIterator(Element parent) {
49            child = advanceToElement(parent.getFirstChild());
50        }
51
52        private static Element advanceToElement(Node firstChild) {
53            Node node = firstChild;
54            while (node != null && !(node instanceof Element)) {
55                node = node.getNextSibling();
56            }
57            return (Element) node;
58        }
59
60        @Override
61        public boolean hasNext() {
62            return child != null;
63        }
64
65        @Override
66        public Element next() {
67            if (!hasNext()) {
68                throw new NoSuchElementException("No next sibling.");
69            }
70            Element next = child;
71            child = advanceToElement(child.getNextSibling());
72            return next;
73        }
74    }
75
76    /**
77     * An exception that is thrown if there was an error while getting the capabilities of the WMS server.
78     */
79    public static class WMSGetCapabilitiesException extends Exception {
80        private final String incomingData;
81
82        /**
83         * Constructs a new {@code WMSGetCapabilitiesException}
84         * @param cause the cause (which is saved for later retrieval by the {@link #getCause()} method)
85         * @param incomingData the answer from WMS server
86         */
87        public WMSGetCapabilitiesException(Throwable cause, String incomingData) {
88            super(cause);
89            this.incomingData = incomingData;
90        }
91
92        /**
93         * Constructs a new {@code WMSGetCapabilitiesException}
94         * @param message   the detail message. The detail message is saved for later retrieval by the {@link #getMessage()} method
95         * @param incomingData the answer from the server
96         * @since 10520
97         */
98        public WMSGetCapabilitiesException(String message, String incomingData) {
99            super(message);
100            this.incomingData = incomingData;
101        }
102
103        /**
104         * The data that caused this exception.
105         * @return The server response to the capabilites request.
106         */
107        public String getIncomingData() {
108            return incomingData;
109        }
110    }
111
112    private List<LayerDetails> layers;
113    private URL serviceUrl;
114    private List<String> formats;
115
116    /**
117     * Returns the list of layers.
118     * @return the list of layers
119     */
120    public List<LayerDetails> getLayers() {
121        return Collections.unmodifiableList(layers);
122    }
123
124    /**
125     * Returns the service URL.
126     * @return the service URL
127     */
128    public URL getServiceUrl() {
129        return serviceUrl;
130    }
131
132    /**
133     * Returns the list of supported formats.
134     * @return the list of supported formats
135     */
136    public List<String> getFormats() {
137        return Collections.unmodifiableList(formats);
138    }
139
140    /**
141     * Gets the preffered format for this imagery layer.
142     * @return The preffered format as mime type.
143     */
144    public String getPreferredFormats() {
145        if (formats.contains("image/jpeg")) {
146            return "image/jpeg";
147        } else if (formats.contains("image/png")) {
148            return "image/png";
149        } else if (formats.isEmpty()) {
150            return null;
151        } else {
152            return formats.get(0);
153        }
154    }
155
156    String buildRootUrl() {
157        if (serviceUrl == null) {
158            return null;
159        }
160        StringBuilder a = new StringBuilder(serviceUrl.getProtocol());
161        a.append("://").append(serviceUrl.getHost());
162        if (serviceUrl.getPort() != -1) {
163            a.append(':').append(serviceUrl.getPort());
164        }
165        a.append(serviceUrl.getPath()).append('?');
166        if (serviceUrl.getQuery() != null) {
167            a.append(serviceUrl.getQuery());
168            if (!serviceUrl.getQuery().isEmpty() && !serviceUrl.getQuery().endsWith("&")) {
169                a.append('&');
170            }
171        }
172        return a.toString();
173    }
174
175    /**
176     * Returns the URL for the "GetMap" WMS request in JPEG format.
177     * @param selectedLayers the list of selected layers, matching the "LAYERS" WMS request argument
178     * @return the URL for the "GetMap" WMS request
179     */
180    public String buildGetMapUrl(Collection<LayerDetails> selectedLayers) {
181        return buildGetMapUrl(selectedLayers, "image/jpeg");
182    }
183
184    /**
185     * Returns the URL for the "GetMap" WMS request.
186     * @param selectedLayers the list of selected layers, matching the "LAYERS" WMS request argument
187     * @param format the requested image format, matching the "FORMAT" WMS request argument
188     * @return the URL for the "GetMap" WMS request
189     */
190    public String buildGetMapUrl(Collection<LayerDetails> selectedLayers, String format) {
191        return buildRootUrl() + "FORMAT=" + format + (imageFormatHasTransparency(format) ? "&TRANSPARENT=TRUE" : "")
192                + "&VERSION=1.1.1&SERVICE=WMS&REQUEST=GetMap&LAYERS="
193                + selectedLayers.stream().map(x -> x.ident).collect(Collectors.joining(","))
194                + "&STYLES=&SRS={proj}&WIDTH={width}&HEIGHT={height}&BBOX={bbox}";
195    }
196
197    /**
198     * Attempts WMS "GetCapabilities" request and initializes internal variables if successful.
199     * @param serviceUrlStr WMS service URL
200     * @throws IOException if any I/O errors occurs
201     * @throws WMSGetCapabilitiesException if the WMS server replies a ServiceException
202     */
203    public void attemptGetCapabilities(String serviceUrlStr) throws IOException, WMSGetCapabilitiesException {
204        URL getCapabilitiesUrl = null;
205        try {
206            if (!Pattern.compile(".*GetCapabilities.*", Pattern.CASE_INSENSITIVE).matcher(serviceUrlStr).matches()) {
207                // If the url doesn't already have GetCapabilities, add it in
208                getCapabilitiesUrl = new URL(serviceUrlStr);
209                final String getCapabilitiesQuery = "VERSION=1.1.1&SERVICE=WMS&REQUEST=GetCapabilities";
210                if (getCapabilitiesUrl.getQuery() == null) {
211                    getCapabilitiesUrl = new URL(serviceUrlStr + '?' + getCapabilitiesQuery);
212                } else if (!getCapabilitiesUrl.getQuery().isEmpty() && !getCapabilitiesUrl.getQuery().endsWith("&")) {
213                    getCapabilitiesUrl = new URL(serviceUrlStr + '&' + getCapabilitiesQuery);
214                } else {
215                    getCapabilitiesUrl = new URL(serviceUrlStr + getCapabilitiesQuery);
216                }
217            } else {
218                // Otherwise assume it's a good URL and let the subsequent error
219                // handling systems deal with problems
220                getCapabilitiesUrl = new URL(serviceUrlStr);
221            }
222            serviceUrl = new URL(serviceUrlStr);
223        } catch (HeadlessException e) {
224            Main.warn(e);
225            return;
226        }
227
228        final String incomingData = HttpClient.create(getCapabilitiesUrl).connect().fetchContent();
229        Main.debug("Server response to Capabilities request:");
230        Main.debug(incomingData);
231
232        try {
233            DocumentBuilder builder = Utils.newSafeDOMBuilder();
234            builder.setEntityResolver((publicId, systemId) -> {
235                Main.info("Ignoring DTD " + publicId + ", " + systemId);
236                return new InputSource(new StringReader(""));
237            });
238            Document document = builder.parse(new InputSource(new StringReader(incomingData)));
239            Element root = document.getDocumentElement();
240
241            // Check if the request resulted in ServiceException
242            if ("ServiceException".equals(root.getTagName())) {
243                throw new WMSGetCapabilitiesException(root.getTextContent(), incomingData);
244            }
245
246            // Some WMS service URLs specify a different base URL for their GetMap service
247            Element child = getChild(root, "Capability");
248            child = getChild(child, "Request");
249            child = getChild(child, "GetMap");
250
251            formats = getChildrenStream(child, "Format")
252                    .map(Node::getTextContent)
253                    .filter(WMSImagery::isImageFormatSupportedWarn)
254                    .collect(Collectors.toList());
255
256            child = getChild(child, "DCPType");
257            child = getChild(child, "HTTP");
258            child = getChild(child, "Get");
259            child = getChild(child, "OnlineResource");
260            if (child != null) {
261                String baseURL = child.getAttribute("xlink:href");
262                if (!baseURL.equals(serviceUrlStr)) {
263                    Main.info("GetCapabilities specifies a different service URL: " + baseURL);
264                    serviceUrl = new URL(baseURL);
265                }
266            }
267
268            Element capabilityElem = getChild(root, "Capability");
269            List<Element> children = getChildren(capabilityElem, "Layer");
270            layers = parseLayers(children, new HashSet<String>());
271        } catch (MalformedURLException | ParserConfigurationException | SAXException e) {
272            throw new WMSGetCapabilitiesException(e, incomingData);
273        }
274    }
275
276    private static boolean isImageFormatSupportedWarn(String format) {
277        boolean isFormatSupported = isImageFormatSupported(format);
278        if (!isFormatSupported) {
279            Main.info("Skipping unsupported image format {0}", format);
280        }
281        return isFormatSupported;
282    }
283
284    static boolean isImageFormatSupported(final String format) {
285        return ImageIO.getImageReadersByMIMEType(format).hasNext()
286                // handles image/tiff image/tiff8 image/geotiff image/geotiff8
287                || isImageFormatSupported(format, "tiff", "geotiff")
288                || isImageFormatSupported(format, "png")
289                || isImageFormatSupported(format, "svg")
290                || isImageFormatSupported(format, "bmp");
291    }
292
293    static boolean isImageFormatSupported(String format, String... mimeFormats) {
294        for (String mime : mimeFormats) {
295            if (format.startsWith("image/" + mime)) {
296                return ImageIO.getImageReadersBySuffix(mimeFormats[0]).hasNext();
297            }
298        }
299        return false;
300    }
301
302    static boolean imageFormatHasTransparency(final String format) {
303        return format != null && (format.startsWith("image/png") || format.startsWith("image/gif")
304                || format.startsWith("image/svg") || format.startsWith("image/tiff"));
305    }
306
307    /**
308     * Returns a new {@code ImageryInfo} describing the given service name and selected WMS layers.
309     * @param name service name
310     * @param selectedLayers selected WMS layers
311     * @return a new {@code ImageryInfo} describing the given service name and selected WMS layers
312     */
313    public ImageryInfo toImageryInfo(String name, Collection<LayerDetails> selectedLayers) {
314        ImageryInfo i = new ImageryInfo(name, buildGetMapUrl(selectedLayers));
315        if (selectedLayers != null) {
316            Set<String> proj = new HashSet<>();
317            for (WMSImagery.LayerDetails l : selectedLayers) {
318                proj.addAll(l.getProjections());
319            }
320            i.setServerProjections(proj);
321        }
322        return i;
323    }
324
325    private List<LayerDetails> parseLayers(List<Element> children, Set<String> parentCrs) {
326        List<LayerDetails> details = new ArrayList<>(children.size());
327        for (Element element : children) {
328            details.add(parseLayer(element, parentCrs));
329        }
330        return details;
331    }
332
333    private LayerDetails parseLayer(Element element, Set<String> parentCrs) {
334        String name = getChildContent(element, "Title", null, null);
335        String ident = getChildContent(element, "Name", null, null);
336
337        // The set of supported CRS/SRS for this layer
338        Set<String> crsList = new HashSet<>();
339        // ...including this layer's already-parsed parent projections
340        crsList.addAll(parentCrs);
341
342        // Parse the CRS/SRS pulled out of this layer's XML element
343        // I think CRS and SRS are the same at this point
344        getChildrenStream(element)
345            .filter(child -> "CRS".equals(child.getNodeName()) || "SRS".equals(child.getNodeName()))
346            .map(child -> (String) getContent(child))
347            .filter(crs -> !crs.isEmpty())
348            .map(crs -> crs.trim().toUpperCase(Locale.ENGLISH))
349            .forEach(crsList::add);
350
351        // Check to see if any of the specified projections are supported by JOSM
352        boolean josmSupportsThisLayer = false;
353        for (String crs : crsList) {
354            josmSupportsThisLayer |= isProjSupported(crs);
355        }
356
357        Bounds bounds = null;
358        Element bboxElem = getChild(element, "EX_GeographicBoundingBox");
359        if (bboxElem != null) {
360            // Attempt to use EX_GeographicBoundingBox for bounding box
361            double left = Double.parseDouble(getChildContent(bboxElem, "westBoundLongitude", null, null));
362            double top = Double.parseDouble(getChildContent(bboxElem, "northBoundLatitude", null, null));
363            double right = Double.parseDouble(getChildContent(bboxElem, "eastBoundLongitude", null, null));
364            double bot = Double.parseDouble(getChildContent(bboxElem, "southBoundLatitude", null, null));
365            bounds = new Bounds(bot, left, top, right);
366        } else {
367            // If that's not available, try LatLonBoundingBox
368            bboxElem = getChild(element, "LatLonBoundingBox");
369            if (bboxElem != null) {
370                double left = getDecimalDegree(bboxElem, "minx");
371                double top = getDecimalDegree(bboxElem, "maxy");
372                double right = getDecimalDegree(bboxElem, "maxx");
373                double bot = getDecimalDegree(bboxElem, "miny");
374                bounds = new Bounds(bot, left, top, right);
375            }
376        }
377
378        List<Element> layerChildren = getChildren(element, "Layer");
379        List<LayerDetails> childLayers = parseLayers(layerChildren, crsList);
380
381        return new LayerDetails(name, ident, crsList, josmSupportsThisLayer, bounds, childLayers);
382    }
383
384    private static double getDecimalDegree(Element elem, String attr) {
385        // Some real-world WMS servers use a comma instead of a dot as decimal separator (seen in Polish WMS server)
386        return Double.parseDouble(elem.getAttribute(attr).replace(',', '.'));
387    }
388
389    private static boolean isProjSupported(String crs) {
390        return Projections.getProjectionByCode(crs) != null;
391    }
392
393    private static String getChildContent(Element parent, String name, String missing, String empty) {
394        Element child = getChild(parent, name);
395        if (child == null)
396            return missing;
397        else {
398            String content = (String) getContent(child);
399            return (!content.isEmpty()) ? content : empty;
400        }
401    }
402
403    private static Object getContent(Element element) {
404        NodeList nl = element.getChildNodes();
405        StringBuilder content = new StringBuilder();
406        for (int i = 0; i < nl.getLength(); i++) {
407            Node node = nl.item(i);
408            switch (node.getNodeType()) {
409                case Node.ELEMENT_NODE:
410                    return node;
411                case Node.CDATA_SECTION_NODE:
412                case Node.TEXT_NODE:
413                    content.append(node.getNodeValue());
414                    break;
415                default: // Do nothing
416            }
417        }
418        return content.toString().trim();
419    }
420
421    private static Stream<Element> getChildrenStream(Element parent) {
422        if (parent == null) {
423            // ignore missing elements
424            return Stream.empty();
425        } else {
426            Iterable<Element> it = () -> new ChildIterator(parent);
427            return StreamSupport.stream(it.spliterator(), false);
428        }
429    }
430
431    private static Stream<Element> getChildrenStream(Element parent, String name) {
432        return getChildrenStream(parent).filter(child -> name.equals(child.getNodeName()));
433    }
434
435    private static List<Element> getChildren(Element parent, String name) {
436        return getChildrenStream(parent, name).collect(Collectors.toList());
437    }
438
439    private static Element getChild(Element parent, String name) {
440        return getChildrenStream(parent, name).findFirst().orElse(null);
441    }
442
443    /**
444     * The details of a layer of this wms server.
445     */
446    public static class LayerDetails {
447
448        /**
449         * The layer name
450         */
451        public final String name;
452        public final String ident;
453        /**
454         * The child layers of this layer
455         */
456        public final List<LayerDetails> children;
457        /**
458         * The bounds this layer can be used for
459         */
460        public final Bounds bounds;
461        public final Set<String> crsList;
462        public final boolean supported;
463
464        public LayerDetails(String name, String ident, Set<String> crsList, boolean supportedLayer, Bounds bounds,
465                List<LayerDetails> childLayers) {
466            this.name = name;
467            this.ident = ident;
468            this.supported = supportedLayer;
469            this.children = childLayers;
470            this.bounds = bounds;
471            this.crsList = crsList;
472        }
473
474        public boolean isSupported() {
475            return this.supported;
476        }
477
478        public Set<String> getProjections() {
479            return crsList;
480        }
481
482        @Override
483        public String toString() {
484            if (this.name == null || this.name.isEmpty())
485                return this.ident;
486            else
487                return this.name;
488        }
489    }
490}
Note: See TracBrowser for help on using the repository browser.