Creating Interoperable Tiled Maps
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| 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 | 10.5446/68449 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
| |
| Keywords |
FOSS4G Europe 2024 Tartu31 / 156
6
33
35
53
55
59
61
67
70
87
97
99
102
103
104
105
107
111
121
122
123
124
125
126
127
128
134
144
150
151
155
00:00
Process (computing)Presentation of a groupTessellationGoodness of fitTexture mapping
00:11
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
05:23
Software developerCartesian coordinate systemArithmetic meanTerm (mathematics)MereologyComputer animation
05:36
Social classCore dumpComputer animation
05:49
Texture mappingCuboidCodeUniform resource locatorServer (computing)Cartesian coordinate systemTessellationTemplate (C++)MetadataMereologyVector spaceComputer animation
07:07
Broadcast programmingImage registrationCuboidComputer animationLecture/Conference
07:19
Vector spaceCore dumpSocial classCivil engineeringInformationDescriptive statisticsClient (computing)Core dumpConformal mapCodeCuboidSpeech synthesisSocial classVideoconferencingMetadataMereologyPoint (geometry)Texture mappingCartesian coordinate systemTemplate (C++)Object-oriented programmingComputer animation
08:59
Open setCASE <Informatik>Conformal mapSocial classTessellationComputer animation
09:22
Demo (music)MUDTessellationOpen setTemplate (C++)CASE <Informatik>Software developerPoint (geometry)Projective planeCodeWeb 2.0Link (knot theory)Texture mappingComputer animation
10:12
HexagonConformal mapTessellationImplementationTemplate (C++)CodeSocial classComputer animation
10:40
Multiplication signWebsiteTessellationSoftware developerComputer animationPanel painting
10:52
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
13:08
Least squaresGEDCOMComputer animation
Transcript: English(auto-generated)
00:00
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,
00:21
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.
00:40
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,
01:01
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
01:21
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
01:41
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.
02:06
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
02:24
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
02:43
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.
03:08
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
03:21
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
03:41
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
04:03
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
04:21
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,
04:46
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
05:01
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
05:21
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...
05:43
If this works... Okay, so yes. So this is an example where I'm flying to the bounding box of the map
06:05
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,
06:25
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.
06:41
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
07:05
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.
07:27
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
07:41
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.
08:04
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
08:22
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
08:42
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.
09:01
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
09:20
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.
09:45
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.
10:07
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
10:21
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.
10:42
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
11:05
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,
11:27
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
11:44
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
12:05
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
12:20
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.
12:44
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,
13:03
I invite you to visit this URL. And that's it, thank you very much.