So I would like to thank organizers for inviting me. It's my first time in Prague and I'm very

happy also that I visited the Faculty of Civil Engineering. I am also from Faculty of Civil Engineering in Belgrade. So I will say a few things about my department and the faculty and the company where I'm co-owner. So I'm from Faculty of Civil Engineering and I'm also head of

laboratory OSGL that focus on the promotion of open source technology in education research and in industry. As a faculty we had a few research projects mostly focusing on use

of remote sensing in agriculture and building the platforms that aiming to support farmers by providing information and data to the farmers.

We have also ongoing project service focusing on use of machine learning and artificial intelligence for agriculture based on remote sensing data and based on meteorological observations.

As a company D-Lab we had a few projects also mostly focusing on remote sensing in agriculture and we have also many projects that are focused on building web mapping applications relating to

the open data science. We built a map application that provides geospatial data led to the project and also the services WebGL services for open data science.

So what we are going to talk about today we are going to talk about the web mapping history and evolution about the web mapping services. We are going to try some examples

of using web mapping services and we are going to see some application of building web mapping client firstly by using QGIS and extension QGIS to web and secondly we

are going to try some code with HTML and JavaScript using OpenLayers to the cloud. So if we go to web mapping we can say that web mapping studies technologies of design and implementation of maps using the internet as a medium and if we remember the typical

definition of the map we can say that map is abstraction and selection of geographic reality where we have clearly highlighted shapes and relation of reality

but when we include web and the internet as a medium map has some new functionality so we are used to see that maps are now part of search engines for exploring geospatial data

then it can be interfaced to local spatial data infrastructure we know when we making map with the end use with that technologies we include multimedia as default and similar. Here are some examples of web mapping applications.

If we want to see evolution of web mapping we should see firstly evolution of the web and there are some terminology that includes web 1.0, web 2.0 and web 3.0. So if we go back

to the web 1.0 we can say that it is a web mostly focused on the users that are only the

readers of the website so in the beginning we had websites where for example somebody present a CV on the website and the user is mostly the one who can read and with no

interaction with the website it's let's say read-only internet. In the beginning in 2000 it is a new term developed web 2.0 and we can call that web let's say that era in the history of web development social web because it is focused

on the user generated content and the users are let's say in the same time creators of the content of the web pages and the web and typical web related to web 2.0 are let's say

YouTube or social networks and similar and now we have a term web 3.0 or semantic web it's not so clear what is the definition of the web 3.0 but

it tries to make application that can read and interact with the content of application similar like humans but we can say that the 3.0 mostly include machine learning, artificial intelligence

and the cloud technologies, blockchain technologies, smart contract and similar. For example example of the 3.0 could be the platform that we are building in the project Bitcoin it tries to use artificial intelligence and machine learning together with remote sensing data and

can provide information to the farmer and to the insurance company about the damage that can happen during some extreme events and it can trigger smart contract to be

proceed with insurance company and also can be automatically approved by farmers so it's some kind of let's say complex website based on the smart contract, blockchain, artificial intelligence and remote sensing data to provide information for the both sides insurance company and to the

firms. So if we go now to the evolution of web mapping we can see some very important events in web mapping history. So let's say that mapping started in 1990s

and the first important event in web mapping was creation of park map viewer in 1993.

After that in 1994 already we have a first realization of the map server and so start of web mapping services let's say can be located in 1994. After that we have important event

when map quest produced web mapping application for USA in 2001 geo server is realized 2004 is very important because we have first let's say web 2.0 map application open street map

where user generated the content and provided geospatial data to the platform. After that we have a google street view then in 2008 we have google maps and after that

we have geo node and many also web mapping applications and evolutions evolution started after 2010. If we divide the mapping history in the eras let's say we can

we can show nine eras in the web mapping history and there is also very good article related to the evolution of the web map provided here it is open access and it is recommended to read if you are interested in this technology. So in the mapping history we

can divide nine eras and these stars that you can see on the screen it's approximately beginning

of the development of this era but many of these are still in developing and it's let's say there is no end of many of this era and ranges in the history. So

the first era was static the mapping era and we have that Steve puts firstly published the maps on the internet and what was it it was mostly static web mapping application that contained just images and in this you had links to the different zoom for

example for the images and then you click on the four different zoom levels it just just direct you to the different static heart MLM. After that we have a second era

and it is let's say beginning of modern web mapping application of development of modern web mapping application. So we had a national atlas of Canada and the technology

that it was used for the development of the national atlas of Canada was similar like technology that is used today because they try to make web mappings server application

that provide data to the end user to the client and based on the actions of the user like zoom pan or a selection of the map server rendered the output map to the client and

after that started service because people saw that development of national atlas of Canada is the right technology but the server side was made just for that

particular application so the developers they saw that providing standard services that can be consumed from many client application or desktop this application is the better option

and let's say then it started that mapping data based on the mapping services and very let's say key elements of that era is development of map server and geo server application that provides the geospatial services

and on another side client application that can consume standardized services like open areas lifted and similar after that we had interactive web mapping era and it is the key

technology in that did that period was iax technology and it is era connected to the build of web mapping mashups application mostly using google maps apio similar

so what was the advantage of iax technology it was the first time that the client application can communicate to the server application after loading the page and then only one component of the page can send request to the server side

and the refresh is related just to that component so it is the first time that client application can communicate to the server side after loading the page and it can communicate

in background without reloading the whole page and all content of the web page then we have a collaborative mapping era and the key let's say event related to that

the mapping era was open street map started in 2004 and it started like let's say just like a practice for the UK but it explodes to the whole world we now have let's say user generated very good high resolution maps that can provide you not

only the maps but also the data geospatial data then we have the digital globe the mapping era and let's say very important event in that era is google earth and

representation of the let's say whole world in 3d provided to the end users also what is related to that era that we have a development of 3d format like kml and we have

also let's say first time that we can provide space time animation by using kml in that we have also another digital globe solutions like nasa world win or cesium or microsoft

or then era related to the user locations let's say is location based services

era that started just after the digital global era what is the important for this that when we have devices that could provide a location of the user requests related to the geospatial data are focused on the position of the user so

we saw it with like marketing in for example google maps when you search restaurants nearby or even we can see that the era with pokemon go and let's say game industry

we can also see that there is a cloud mapping era and here is one application that provides provides web mapping application based on the

google earth engine data that provides let's say everything as a service in the background and on the end we can imagine that new web mapping applications are going to be

in let's say web 3.0 way or let's say intelligent era so that we can expect expect that new web mapping applications are going to be built based on in the background based on machine learning artificial intelligence maybe also include some blockchain technology or similar

but if you see the vision of let's say this future web apps according to this article that is provided link is here we have three layers and the first layer is just physical that represent the world as it is the second

layer let's say it's digital information layer it is something like a digital tree so we have everything in 3d representing the almost copy of the world maybe we have also

included some sensor observation data in the buildings or related to the infrastructure in the let's say in this part of some city and on the end maybe in the future we are going to

to build some specific interface that that can be based on the augmented reality virtual reality that can listen to the voice commands and similar and that that final layer could provide some new let's say information and data based on the digital twin and sensor observation

networks in the copy of this reality let's say so and now we are going to the part of the workshop that will try to explain what are web mapping services and how to use

web mapping services and if we see the typical architecture of the web mapping application we can see that there are two sides the first one is client side and the second one is server side

and in typical web mapping application what we need to have on the server side is a web server which has appropriate software that can communicate with the client for example

and on that machine we also have to have web mapping server that can provide geospatial application geospatial data to the client a typical web map server app is the map server

or geoserver or let's say some s3 or commercial servers or applications and on the end on the client side side we have a web map client typically written in javascript but the web mapping

client can be a desktop gis software that can consume geospatial data from the web provided from web mapping server so this schema of the mapping services can illustrate how does it

work so if i'm on the client side i can use just web browser to send some requests to the server then a server web server application like Apache can forward it to the web mapping server

like geoserver geoserver can understand the request that is sent from my browser and then can provide some back some data to me and my client in the browser for example open layer so

leaflet can render the spatial data to me directly or if i use a desktop application like qgis it is similar like i explained but then in that case a qgis send request to the remote server remote server understand the request sent from qgis and send back

the data geospatial data to me and it is a rendered and provided to qgis in a similar way like that i use spatial data from the my machine so if we go back to the

typical architecture of the web mapping application this is the example of application that we made as a we made for this project open data science and here we can see that we have three

layers the first one is data layer where we have spatial data in huge in post gis we have vector data in a file system we have raster data and we have set of metadata that relates

both to the raster center vector in the middle we have the mapping application in this case is geoserver that provides services to the end users to the client we have also rest api built on general rest framework to provide spatial and spatial temporal queries directly to the

client in the middle where we also have geo network that provide method data that you can explore what is offered through the web gi services and on the finally on the client side we have a

client built on open layers uh it is built also as react application using react framework and the user uh end user can

to can make access to the all the data through the final app so final app provides uh not only geospatial data also the queries for spatial and spatial temporal data

and using this app you can be guided to see metadata in geo network what is the important in the web mapping uh theory it is that that from let's say era from services era we have uh standardized services

and the open geospatial consortium is the international body that support implementation of standards and protocols related to geospatial data and we are going to see some

of the standards and services related to web mapping services web coverage services web feature services and web processing services so what is the web map service let's say it's standard protocol to serve uh geo reference

image style images so it is not going to provide you a source gis data it is going to provide your style image of the layer so mostly uh these services are used in a web mapping application

as a background map or as a map that represents some phenomena and going to be let's say the the core map like for example length cover map or similar so uh once more the the the the

final uh output that is provided from web map services is jpeg or png so it's not gis format

uh we have also evolution of web mapping services and there are different versions of mapping services starting from 1.0 to 1.3 and some parameters are not the same like in the first and the final let's say version of the services two key uh let's say two key services

that it that web mapping services provides uh get map and get capabilities get capabilities

provide you description of the all layers that are that can be consumed by web mapping services and get map provides you style raster images in png or jpeg format so this is the typical

protocol let's say way of communication from a client to the server side and this is the example of the mapping services for get capabilities so in the first part we have

address to the web mapping service then it then is question mark and we define what service we are going to use what version and we use and sign to define parameters that we are going to use in this case we are going just to to use a

parameter for version and the request is get capabilities what is typically for for the web mapping services that the answer that you are going to get is a xml file in this case we have list of all uh wms layers that are sorted from this

uh machine and we have a in this case also the title of each layer some abstract and boundary blocks related to that specific layer we also have list of all available

coordinate reference systems that can be used from that server uh if we try to use something like get capabilities in qgrs uh it is easy and then we just need to provide

uh core url address to the add wms in qgrs and then we will have something like get capabilities but in human readable form so we have a list of all layers that can be

consumed through wms services uh if we try to uh request get map example so we have something like here uh similar like like before we have to define

uh url address to the wms then we can define the version we can define request in this case get map then we can we have to define the title of the layer that we are going to consume

and then we can provide boundary books or spatial range we can then define the dimension of the output and on the end format so if we build this url but not separately in in

one piece put it in a browser we will have something like this then a server will send to us geo referenced image of requested layer and here also we have two examples that do the same

the first one points directly to the wms service and the second one point to the geo server and you can use if it's provided not only wms you can use web

feature service web coverage and similar and it is mostly typical for geo server that you have this second option to uh define core to the web services and then in services you defined are you going to use wms web feature services for the coverage services

uh we we now have example uh for the get map that consume uh open uh data science data provided for the euro so in this case we use get map to take digital elevation model

uh 30 meters resolution we define in this case also boundary books and this boundary box is like let's say for serbia so for example if you want to try i sent the link

to the in zoom to all participants you can now try to let's say uh take this wms layer but not for serbia let's say for check here for nearby product so in this case we what we need to change is only this boundary box parameter to define uh spatial extent of the the wms that

we are we would like to get so if i if i try to click here or copy paste in the browser

i would get something like this so if i now try to change this extent let's say 15

let's say in that case i would get another spatial agent another style uh layer to be

consumed so uh if i use a different version of uh web mapping service and i

need to define spatial range uh and spatial range is defined in a

uh the wgs84 uh in that case i have to uh take into account that

order of easting and nothing is different so in that case order is first north and then easting and in previous was easting nothing so in some versions uh of wms it can be that some parameters are slightly different from version to version so if we see then uh all together there are

many options when you request wms and uh these options are mostly listed here some are mandatory and some are optional and we let's say uh pass through the all mandatory uh

parameters so if we try to do it in a qgis it is similar and let's try to do it now so if i use qgs i can go uh layer add layer and a wms layer

then there is option to make connection to the server that provides uh wms in this case i have this uh geo server that provides all the data related to open data science projects

and uh here here is url to uh server when i click connect then i have let's say get capabilities

that provide me the list of all available layers in this case let's say i will take some layer and if i go to it it appears here and now i have wms for providing them from the open

data science project and i can also add some tiling layer for example open street map or

similar so it's almost the same technology like we use for wms when we

consume spatial data and so if i provide some transparency so let's say now we we have qgs and

all the data we use from the services so in this case q g s is a client client that

consume spatial data so for the background maps you can use some of these links that i provided

in this slide but also you can use some plug-in from qgs that can provide you base maps in the qgs for example it is possible to now to make a map and print the map from data that

are provided from the services in this case let's say we can try to make a map from this data that we have so let's we can go to the project to print layout then we can

add the data and let's also add some title my map using wms and xyz and for example let's try

to add to this map and we can see that we don't like this legend and there is a question

can we make something better but the answer is going to come here so in wms we can also use a request to get legend and so for example this is the legend for the layer that we explore

this damn layer and let's say i will delete this one i don't like and then i should go to add a picture for example

here and i could say that it is going to be raster image and here i can just point to the for this map we have even legend search through the through the web mapping services so

let's let's say that we built a simple map ready to be printed or exported as pdf just using services provided from gs server but what we also can do we can try to build simple

application based on open labs or leaflet from qgis and export it as a html and

javascript and let's try to do it if you have installed qgis to web then it's possible to combine these services it can be also based on the local data from machine so i can go to the

go to the web qgs to web and create the map and i have list of two layers here now it's background this open street map and this wms is in front and i can choose here some options let's say

i'm going to build a web mapping application based on open layers and then if i go to export and it's now created and you can see that we have now a simple

web map application that has open street map in the background and it use this digital elevation model layer from wms if we see here if we see the link

it is from some temporary folder we can go there and see the structure

of this simple application so if i go here i will see the folder in this folder i have some q sub folders and for example this is the whole application in html if i

open this let's say in some browser in some editor for example not that get it if you are in a bond or visual studio code or something similar i will have this

so this is html and it provides me a link to the some javascript in javascript is all related to the web map that we saw here so i have this container

here and it says that it has id map and the map is placed there and here i have links to the javascript from open layer resources that provide me functionality

to this company for example we can go and see for example this layers it's let's say a heart of this script and if we go there i can open it also in some code editor

you will see here that it uses open layers and it uses similar request that i showed before and here we have this wms in typical open layers notation that consumes

this damn layer provided here and the base layer is this one here provided as a tiling service from open street now so this is more or less the the core of open less client so

just in this case qgrs or let's say qgrs plugin made it for us so on the end of this lecture we will try to make some web mapping application by using open layers and html and

it's going to make a json file from the shape file and import it in the uh client and it's going to be a simple web app web mapping

yeah it can even you can directly directly put the save option to ftp so it can directly transfer it to the some server that can publish it to the web so what's the next

next is what we saw so the core of this simple app is the data that are going to be imported in the script on the end and here we have two layers the first one is a background layer and second one is wms provided from open data science

geo server and here we have a parameters related to wms in open layers client so it is very similar that we saw before and there are some also optional and mandatory parameters that

has to be provided what we have more related to wms we have an option also to take feature info describe layer and get legend graphics so we saw a few examples related to

wms the what is the next the next is a web feature service so the key concept of web feature service is to provide a row vector data to the end user so similarly like we constructed wms requests http request we can request from a server to give us a row

vector data row vector data by default is provided in geographic gml geographic market

language but we can also define parameters for example s3 shape file or json or similar and there are also web feature service for transactions in that case you can use

web feature service to directly manipulate with the vector data on the server for example you can delete some feature or edit some features standard queries that you can use by using web feature services again get get capabilities

describe feature type get feature get gml object transaction it's optional if it's enabled and there is also block feature only that is possible only it's possible when

the transactions are enabled in w in web mapping services so for example here we construct one request code is similar like before first part of your url is the location of wms then we

define service in this case is web feature service then we define a version and then get feature in this case we are going to ask for some temperature trends and this is the name

of the layer that i asked for and i also say give me only two first features let's say two first stations and in this case i define the output format json so if i if i try to execute

this it is going to be like this so if i now i have only two first station if i

change this for example parameter max features to let's say 22 and make request it is going to

give me 22 point data for the meteorological station in serbia giving me also the coordinates and the attribute data to the old station that are served from this geoserver so in this case

here we have also examples from open data science data set and if i remember good here you have some lucas in situ data consumed by using web feature services in this case i also

limited the number of data that is going to be delivered in this case is five and we have again data in a json format similarly we can define different output for example if

we define shape format in that case web feature services service is going to deliver you zip shape for format with all necessary components to geospatial data what is now a new is a web feature service 3.0 but it's as i know it's not

implemented in a geo server or map server it's still experimental it is going to provide even easier access for vector data and it is going to be similar like rest api for clearing

vector data by using web feature services so similarly like we did before we can consume a web feature service by using qgis but in a case when we use that feature

service then it is easy to take let's say right click and save the file on the local computer as a shape file or geo package or similar here is example also

that you asked before so if i use for example web feature service and download the data as a shape file i can then import the data and qgis and then again if i

building a simple web application web mapping application from qgis to web then it is going to be made for me simply so what's the next web coverage services so web coverage services are

very similar like web feature services but the difference is that web coverage services providing raw raster data to the end users and similarly like web feature services and the web map services we have again get capabilities that list all the layers that can be

delivered through the web coverage services then we have also described coverage that describes specific layer and we have of course get coverage that deliver raster data to the end users

here is one example for get coverage layer and it is very similar like before firstly we have a url that point to the services then we have type of services in this case is the coverage service and then we have also the version

uh request is get coverage then we have to define coverage in this case with coverage id and on the end we have a format a final format for delivery and in uh it is a geotiff format in this case so if i send this request

uh this will try to download this layer for me for example this one and you see

it automatically download the geotiff for me and now of course i can use this geotiff directly here in qgis for example if i go add raster layer based on request that i made

i have this now layer describing temperature trends in serbia consumed by web coverage service on the end i will also just present a little bit of web processing services

so it is possible to to define some processes in geoserver and there is option to

trigger that process from client to the server and what is the the standard uh request that can be used from web processing services is again get capabilities that provide you a list of processes that can be triggered

from client to the server and there is also option describe process and execute describe is it is going to describe what are the necessary parameters to run some processes on the server machine and the final execute is to run to trigger the to run the

process there is also options to get status of the process that is run to get result or this means to terminate the process on the machine

Now, I would try to show you a little bit how to build a webmapping application by using open layers as a client. So what is the typically in the webmapping application that you have some client that you provide to your classes and methods to manipulate with the webmapping application

like classes to add spatial data and then classes to let's say pan, zoom, add for example

some controls like legend or similar. So in this case, we are going to try to use open layers, it's a JavaScript library that implement also the standards of that we mentioned before like WMS, WFS or similar.

And it is let's say robust and very good web client application for building web maps. Also there are a lot of third parties that can be included in open layers and you can

build a rich web mapping application by using open layer. Similar would be leaflet, it is also open source web mapping client or I don't know, there are also probably many more.

So if you try to build the mapping application, we would, we can do it in simple way just in one HTML document. So here you see HTML document and the first part of this document is related to CSS layer

for the open layer. So it is related to the styling of open layers and we in this case are not going to use a library downloaded on the local machine, we use a content delivery network

to show the road to the CSS on the web. What is the next? Then we can define styling for the map in the HTML. In this case, we define just dimensions and we say that the height of our web map is going

to be 400 pixels and the width is 100%. And on the end, we import the JavaScript library that contains everything related to the web map application like classes and methods to import WMS, classes and methods

related to the zoom in, zoom out, pan and similar. So this is the first part, let's say of HTML document. And the second part is the script that tells to the browser, which is in this case,

interpreter to what to do. So in here, we have a script part where we construct in this case, a map object.

It is the key object, of course, in web mapping applications. We said that the target of that map object is a map and this connect div container with

the ID map to the functionality of what we are going to make there. Then we have layers. In this case, we have only open street map layer as a background layer in the application. And on the end, we have view control of the map where we say that we want to from

up from this web mapping up to be the center in the near Prague and zoom level is 11. So what we have now, if we run this HTML, we have simple web map application that has

almost nothing there, only the open state map and open layers is a client that was built this month. So I can try, but you saw this, so I don't need to try.

So the next example would be to extend this simple application to add WMS to the map. And as we saw before in the example from QGIS to web, it is not so difficult.

So we just need to extend this component layers. And in this case, we are going to add WMS layer over the open street map as a background. And here are some parameters that we have to define. In this case, we give title is then we set the capacity to 50% and we define the,

of course, URL to web mapping services, we define which layer we are going to use and which version of the WMS we are going to use.

We also set here extend to WMS layer. So we didn't want to use the whole WMS that cover all the Europe. We set it near Prague, near Czechia.

So, and on the end, we also have to have this view parameter in the map object, and we define the view parameter also, again, to be close to the Prague. And what we have now, we have map application that is little bit, let's say, more complex,

because now we have open street map in the background and we have part of WMS in the web mapping application again. And we can go further. For example, here, we can consume also web feature service in the application.

So we are going to add some vector data from open street, open data science project. So I got 800 length cover data near Prague.

And I combine now open street map as a background, WMS as a one layer, and I added some vector data, additional vector data, and we have something like this map here. So we now combine web feature, web map services, and open street map as a background.

So we can still make it, let's say, more complex. And in this case, we would like to add some control to the map.

And two simple controls is here, like scale line and the position of the mouse. So the object is very similar, like we had before. We define this control related to the coordinates of the mouse.

And we created this control related to the scale line. We extended the object with controls, and now we have something like this. So application is, let's say, more complex. Now we have coordinates on the upper right, and we have a scale line of the lower left,

in the lower left of the app. Then we can also make it more and more complex. What is typically needed when you're building web mapping applications is to have the possibility

to change the layers. And we can now use some extension of open layers that can provide to us layer switches in very simple way. And so in this case, it is added here, also directly by using link to the GitHub

and the layer switcher library. And now we have something like this one here. So now we have web mapping application that we can use layers switcher to choose which

layer is going to be showed. And in this application, we also have two options for the background maps and similar.

And on the end, we can use, for example, extension for cesium to make, let's say, also three-day view possible, you know, web mapping applications. So this is the simple map that contains only WMS that we used in this presentation

all the time. And there are also options to switch from 2D to 3D. And it is, let's say, easy to implement by using this library. So let's say that we extended the whole step with two lines or two or three lines

of code. And so we now have something like this with the option to switch between 2D and 3D. And here is some recommendations to explore.

And I would finish in this part. If you have some questions, you can ask. And Luca will continue to show you a little bit how does it look like in practice related to the web map application that you made for this project. And so Luca, if you have some questions, you can ask.

Somebody asked to link to slides. Okay.

Hello, everyone. My name is Luca, Lucica. I'm working for Guilab as a senior front-end developer and as a geoinformatics engineer.

And I will talk about the product, the data portal that we worked on during the course of this project. So just a moment.

So before we start, okay, this is a really small screen. Okay. Before we start, a little bit about technical things that we needed to integrate during

the development of this platform. This is a ReactJS application, as Milon already mentioned.

We use ReactJS extensively because it's one of the most popular libraries in JavaScript for building user interfaces. And it's really handy when it comes to handling interactions of the users with the map when

we need to pay attention to simultaneous actions and side effects that are always happening in these web.js applications. So on the front end, we have ReactJS. And obviously, as you can see here, it's open layers as a mapping client.

In the background, we have GeoServer as a geospatial data server and Python jungle as a backend that provides us with the API, which we use to collect all the layers produced

and collected throughout the project, and also to provide us with the option to query the data sets and displayed here, as you will see in a moment. So let's begin with the demonstration.

So as you can see, this is a typical web.js application where map component is the main component, and map component handles all the interactions here. And as you can see here, we have a lot of layers, a lot of data sets

that were produced and collected throughout the project. We made all the necessary precautions and steps in order to ensure the high performance in visualizations of these maps and also in querying these maps.

That involves optimizing the data sets, optimizing the server, especially GeoServer, utilizing the caching capabilities of GeoServer. And also optimizing the PostGIS database, which all these image mosaics are indexed.

And all that combined gives us the high performance in these visualizations. So for example, as soon as you start the application, the fault layer here is land cover.

And it's a time series layer. You can use this slider here to query, to browse land cover through time, through years. Maybe we can go like this.

Of course, this is standard WMS with additional parameter for querying through time. That's one option.

Also, you can click to query the data set and see the results in a time series like this. So basically, you can see what's happening in 20 years for this location. There are multiple data sets.

I will not go through all of them. Of course, yesterday you had an opportunity to hear from Carmelo, Carmelo, all of these data sets are imported as well. I will just run through the functionalities here and show you.

So some of these layers have also training points such as this. Of course, we cannot see them because of the zoom level. We made sure that performance in loading these points is at acceptable levels.

So we needed to turn them off for some lower zoom levels because there are a lot of points. But here, as you can see, as soon as we zoom in a little bit closer, we get all these training points where we utilize web feature service and some clustering

clustering functionalities of open layers because these points are very close to each other at this zoom level. But as soon as we zoom in, we can see these groups collapsing. So when we click on the point, we get all these points and their properties here.

These are mainly for land cover right now. One of the probably most interesting functionalities of this tool is the comparison tool

where you can compare two different data sets. We can, for example, select here, quote in land cover and compare it to the land cover produced throughout this project. For example, this is year 2018 and we can select here 2018 as well.

And then we can see the differences. Of course, I'm not sure what's the resolution here on this land cover. Yeah, 30 meters for this one and for this one is 100 meters.

So you can see the differences very vividly. Sorry. Okay. Okay. Of course, if Flare has an uncertainty map, this toggle is enabled and we can toggle

between uncertainty map of the data set and the data set itself. So that's another option.

Of course, users can easily share the link above. Yeah, you can see it. If you want to share some location, for example, by zooming closely, these parameters in the URL

are dynamic and they change as soon as we do something with the map. If you change layer or a background map, it automatically updates the URL and you can share that URL with someone you want to show something to. So that's another feature. And of course, we also have this support page here.

So if you find something that's missing, you can always contact the technical support or write an issue or whatever. So you can also share this link via social networks and bookmark it locally.

There are some helper tools as well. You can use some shortcuts here to change. For example, if I want to go to base map panel, I can press B and switch between, sorry, switch between different base maps.

And as Milan also showed you in the couple of examples, there are some extensions such as cesium extension or 3D view right now. This is 2D view, but we can also switch between globe and 2D map as you can see.

So that's another interesting feature. Each layer selected, you can access the metadata for that layer here and download

that layer as well. So everything is exposed and open. And this is pretty much it about its functionality. So if you have any questions, I'm here to answer. Carl, what's the key to speed up the queries in the visualization?

It involves multiple steps. One of which is first, the data sets might be optimized, dialed into appropriate blocks for data sets that are less, I think, than two or four gigabytes.

We use overviews in GDAL. For example, if we are at lower zoom levels, we don't need to provide the full resolution of an image. We can use a little bit worse because it's not important.

You cannot see the differences at lower zoom levels. But if zoom levels are higher, then you can actually show the real data. So that's another optimization. So data sets should be cloud optimized. That's one thing.

Another thing is optimizing the geospatial data server. So utilize caching capabilities. And for this specifically, these data sets, we publish them as image mosaics.

So image mosaics have some also parameters to consider, such as multiprocessing. And when you query the data set, there are some transformations that are happening on the fly because the geotape is converted to PNG. And this multiprocessing parameter helps in ensuring performance.

So that's another thing. Also, OGS database needs to be optimal as well. We need to make sure that it has enough RAM that multiple users can access at the same time.

And of course, more hardware capabilities to better the performance. So that's pretty much everything that needs to be considered. If you want to have a high performance visualization and was writing normal code.

So how do we get using only one copy to have a seamless visualizations and data service that is efficient?

So it's a one copy. Well, we don't seem to. Actually, no, no, no. I think we use only one copy right now. So they are just

just consuming the same data that you are here. I know, but we have also a solid copy that should have two copies. Also, one more thing, I think it's also important to raster type. It's preferable to be integer, at least integer.

OK, yeah, that's what I was like. Why is this where they have floating or I think they consume more memory. OK, processing and anything you produce basically trying to make it as a byte. Byte is the perfect solution, but if it's not possible, integer is good as well.

And then we can transform on the client here. If we want to show real values in the output of the query or anything, maybe that's another tweak that we should use when we produce it.

More questions? This is the cesium version. Yeah. How stable is it? I mean, is it once you store it and you just always fix it?

At first cesium was not stable at all. They were upgrading the API all the time and it wasn't stable, but right now it seems stable. I didn't see that it crashed in a while, so I think it's pretty stable.

But it has some limitations. I think that web feature service is not possible in cesium and it has some limitations, but I think it's pretty stable since right now it's not free anymore.

It's free up to some point, but they are actually controlling the number of requests of the relief data. It's right now part of ION, I think.

Yeah, just a moment. How can I access this? Yeah, that's it. Well, I think this was on a previous presentation.

Someone mentioned that they need permission to access the slides.

Okay, this is it for me. If you don't have any questions, thank you.