We're sorry but this page doesn't work properly without JavaScript enabled. Please enable it to continue.
Feedback

Creating Interoperable Tiled Maps

00:00

Formal Metadata

Title
Creating Interoperable Tiled Maps
Title of Series
Number of Parts
156
Author
Contributors
License
CC Attribution 3.0 Unported:
You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor.
Identifiers
Publisher
Release Date
Language

Content Metadata

Subject Area
Genre
Abstract
Tiled maps are the backbone of most web applications that show geospatial information. Before OGC API - Tiles was approved, last year, there was not really an interoperable way of creating these maps using a resource oriented architecture and JSON encodings. OGC API - Tiles puts some formality to what people have been doing for years, with 'xyz' tilesets, but it also enables the clients to create a better user experience, by providing metadata, such as title, description or available zoom levels. In this talk we'll provide an overview of this standard, and discuss its advantages, when compared to other standards/specifications, like WMTS or TileJSON. We'll illustrate the benefits of interoperability, with an example that uses FOSS4G software implementing OGC API - Tiles. Finally, we'll point out some resources, available to anyone who wishes to develop and validate an OGC API - Tiles implementation.
Keywords
127
Process (computing)Presentation of a groupTessellationGoodness of fitTexture mapping
Numbering schemeRegular graphParameter (computer programming)Square numberHeat transferVector spaceMean value theoremCore dumpInformationClient (computing)Element (mathematics)MetadataRaster graphicsDifferent (Kate Ryan album)CubeLanding pageCodierung <Programmierung>Template (C++)Zoom lensCodeDescriptive statisticsLimit setCore dumpSoftware developerSocial classLevel (video gaming)Web 2.0Arithmetic meanTerm (mathematics)Conformal mapServer (computing)MetadataNumbering schemeElement (mathematics)TessellationRaster graphicsVector spaceCodierung <Programmierung>Formal grammarComputer configurationCASE <Informatik>Projective planeCuboidImplementationMappingClient (computing)Web pageInteractive televisionQuicksortStandard deviationBitUniform resource locatorCartesian coordinate systemElectric generator2 (number)Multiplication signCommunications protocolAttribute grammarProcess (computing)Physical systemWeb serviceInstance (computer science)Set (mathematics)Latent heatTexture mappingDifferent (Kate Ryan album)SphereType theoryOpen setTemplate (C++)Lecture/ConferenceComputer animation
Software developerCartesian coordinate systemArithmetic meanTerm (mathematics)MereologyComputer animation
Social classCore dumpComputer animation
Texture mappingCuboidCodeUniform resource locatorServer (computing)Cartesian coordinate systemTessellationTemplate (C++)MetadataMereologyVector spaceComputer animation
Broadcast programmingImage registrationCuboidComputer animationLecture/Conference
Vector spaceCore dumpSocial classCivil engineeringInformationDescriptive statisticsClient (computing)Core dumpConformal mapCodeCuboidSpeech synthesisSocial classVideoconferencingMetadataMereologyPoint (geometry)Texture mappingCartesian coordinate systemTemplate (C++)Object-oriented programmingComputer animation
Open setCASE <Informatik>Conformal mapSocial classTessellationComputer animation
Demo (music)MUDTessellationOpen setTemplate (C++)CASE <Informatik>Software developerPoint (geometry)Projective planeCodeWeb 2.0Link (knot theory)Texture mappingComputer animation
HexagonConformal mapTessellationImplementationTemplate (C++)CodeSocial classComputer animation
Multiplication signWebsiteTessellationSoftware developerComputer animationPanel painting
Software developerInformationGoogolStandard deviationFreewareCodeEvent horizonServer (computing)Open setCodierung <Programmierung>Standard deviationImage registrationTessellationSoftware developerServer (computing)Open setDifferent (Kate Ryan album)CodeWebsiteProjective planeStreaming mediaRevision controlCodeUniform resource locatorLevel (video gaming)Public key certificateSuite (music)Software testingDemo (music)Link (knot theory)Web pageCartesian coordinate systemComputer animation
Least squaresGEDCOMComputer animation
Transcript: English(auto-generated)
So, good morning everyone. This presentation I will share with you some thoughts about tile maps, which is something that most of us are familiar with. So, it's an efficient way to serve maps over the web while you pre-render a pyramid of tiles ahead of time,
so they are organized, nicely organized in X, Y, and Z. And then it can be used, there's a dialogue between clients and servers that allows clients to do things like punning and zooming and so on.
So vector tiles are kind of combining the best of the both worlds, because they are efficient as raster tiles, but at the same time they allow us some design flexibility, because you have access to the underlying attributes. And they are using an encoding,
NBT from Mapbox, which is based on the Google Protobuf protocol. So until now, there was no really a standard way of doing tiling, so there were some previous efforts, so there was the
WMTS that you most of you probably know from the first generation of OGC web services, and it adds some concepts, but it was using XML encodings. And then we have TileJson, which provides some metadata about tiles, but
it does not support other coordinate systems other than Spheric Almer Cutter. So OGC API tiles became a standard in late 2022, an OGC standard, and it's basically putting some formality to what people have been doing already for many years with the X, Y, and Z tilesets.
So on top of that, and like TileJson, it adds some metadata that helps clients to do a better job in rendering the maps. So it gives more elements that helps clients to to render the maps in a nicer way. I will demo that in
in a second. So OGC API tiles supports all different types of tiles. There's no reason why we shouldn't, because it's just the rendering scheme. So you can have vector tiles, but you can have also map tiles or coverage tiles. So all of these
scenarios are supported within the standard. And like other OGC APIs, it's based on OpenAPI, so that means you have a description of the API, which is machine readable and can be used by code generators to generate stubs for implementations.
At the same time, if you are a developer and you want to explore the API, you can go to the Swagger page, which reads the OpenAPI document and
transforms it into something nice to read, an HTML interactive page where you can actually try the different endpoints. So for instance, this one is the Swagger page for an example of OGC API tiles, so you can see which sorts of
paths you can find there. So looking a little bit deeper into the standard as I mentioned, the core is very simple. The core is what was approved in 2022. Basically it says that the applications should follow this URL template, which
most of us are using anyway. And then it says that it needs to respond with the status code, so 200 in case everything is okay and so on. So this is basically what we are doing already
on the web. So if you conform to these conformance classes, you can advertise it in your conformance documents the way that I put there. And then there are some other optional conformance classes if you want to go even a little bit further. So for instance,
you can go to tilesets conformance class in the case that you have tilesets that don't cover the entire world, they just cover like a specific bounding box or they have perhaps a different projection or even
just a limited set of zoom levels. Maybe they don't have all zoom levels. And then there is the case where you need to provide metadata for an individual tileset. There's also a conformance class for that. But as I mentioned, these conformance classes are optional and you can
just stick to the core if you like. So let's come to the fun part. What does this mean in terms of application developers? What does this mean for developers? How does it translate? And I think I have here... Let's see if I can...
If this works... Okay, so yes. So this is an example where I'm flying to the bounding box of the map
and then loading two OGC API tiles, vector tile layers from the server and then also advertising the names of the layers that are available. So if you look at the code of this,
you will see that basically this is a leaflet-based application. So you can see that it's calling the layers from an XYZ URL, template URL.
Nothing special about that. But this is the fun part. So it's actually connecting to the endpoints to get the tileset metadata and then dynamically it's retrieving the title of the layers. So the title of the layers is not hard-coded. It's reading it from the endpoint. And this is because of the standard. It's because I know that in this specific endpoint
I can get the the title. And the same thing for the bounding box. So the fly to the bounding box happens because is it? It's okay. It's here. It happens because I have access to the bounding box of the layer.
So yeah, if you look here in more detail, and by the way, if you want you can check out the code for this example. So here you can see the first or the core conformance class here
in the URL template. Oh, we have a video. Let's just, oops. You can watch this later if you like. Two Joannes, one speaking on top of the other. Okay. So this is the core conformance class.
And this is the other part that I was telling you about. So we are retrieving the tileset metadata. And then we are getting the title dynamically from there. And then also the bounding box. And based on the bounding box we can
create a point. And this is the point where the map, the application is flying to when you load it first. So this is how tileset metadata looks like. So actually he has a bunch of other stuff. He has also the description of the map. Of course, you can put something more
useful than what I put there. It has some keywords. And it can have even other things. So this is a piece of information that really clients can use to make a better user experience for the final users.
So of course you can go even further, which is the case where this is natively supported on the tools. So in the case of Leaflet, the OGC API tiles is not natively supported, but because it's conforming to this conformance class, everything kind of works. But I still
need to read the endpoints. But then you have another use case, which is OpenLayers. And in OpenLayers there's native support for OGC API tiles. So it's even easier for a developer to pull a layer. So you can see here I don't need to pass the URL template, because it already knows. So all I need to pass is basically the tiles endpoint.
And I need to specify what is the tileset that I'm using. So the pyramid of tiles that I'm referring to is rendering with a particular projection. In this case it's Web Mercator code. So I have to specify that. And that's it. And then the layer is on the map.
You can also check this example if you like. And there's a link there for the code. So let's talk about implementations. So right now there are 19 implementations registered
on the OGC API tiles website. And these are the implementations that really specifically implement OGC API tiles. But if you think of the first conformance class, so just conforming to the template URL, then that's even more.
So in the rest of the time that I have available, I would like to leave you with some resources if you want to explore more about OGC API tiles. First of all there is the developer website for tiles. It's tilesdeveloper.org. And then you have links for the demos that I showed today
for the standard and for the Swagger page, and a couple of more resources. If you are really interested in knowing better the standard under the hood, you can go to the OGC API workshop website, and then you have deep dives for the different OGC APIs,
explaining how they work, the different resources, and there's one for the OGC API tiles. And if you want to take your application, your server application to the
next level, you can do a compliance certification. So there is a test suite made available by OGC TeamEngine, which by the way, it's an OSU community project. And you can use either the hosted version, or you can download it and use it locally if you
want. It's done in Java, so you can use Maven, or you can use it, run it from within a Docker container. And finally, I invite you to come to the open standards code sprint, which will take
place in London, geovation, next week from Wednesday to Friday. And it will cover all OGC API standards, including OGC API tiles. So if you are interested in knowing more about this, and the first day of the sprint, we'll have a stream of tutorials about different standards.
Registration is free, still open, and it's open to all different levels of knowledge about OGC API, and it's also open to developers, but also other non-coding activities are very welcome during the sprint. So if you want to learn more,
I invite you to visit this URL. And that's it, thank you very much.