WEBVTT

00:00.000 --> 00:12.000
Okay, hello everyone, does that work?

00:12.000 --> 00:13.000
Yeah.

00:13.000 --> 00:18.000
Okay, so I have to speak out.

00:18.000 --> 00:22.000
Okay, so I'm really happy to be here.

00:22.000 --> 00:25.000
It's my first time at Phos Dam, so I'm a little bit nervous.

00:25.000 --> 00:27.000
It's going to be fine.

00:27.000 --> 00:32.000
I'm going to talk to you about Open Layers, which has been mentioned about it in the Phos.

00:32.000 --> 00:34.000
That's great.

00:34.000 --> 00:37.000
So, a little bit of introduction about myself.

00:37.000 --> 00:39.000
My name is Olivia.

00:39.000 --> 00:42.000
I work at a company called Camp for Camp.

00:42.000 --> 00:46.000
A few words about Camp for Camp, so it's a service company.

00:46.000 --> 00:49.000
It does geospatial as well as other stuff.

00:49.000 --> 00:53.000
It's for structure and hosting, space in Switzerland, France,

00:53.000 --> 00:56.000
and Germany, and we're about 200 people.

00:56.000 --> 00:59.000
It's a great company that does a lot of open source,

00:59.000 --> 01:02.000
and the allow me to be here, so it's great.

01:02.000 --> 01:06.000
And I have been working on the Open Layers project for three years now.

01:06.000 --> 01:09.000
I contributed to some stuff.

01:09.000 --> 01:13.000
I touched a bit of everything, but mostly the WebJair Ranger stuff,

01:13.000 --> 01:15.000
which we're going to talk about later.

01:15.000 --> 01:18.000
And you can reach me out and get up,

01:18.000 --> 01:22.000
and go to the Blue Sky, and it's my email address.

01:22.000 --> 01:27.000
So, right, just a quick question first.

01:27.000 --> 01:31.000
Who here has used Open Layers before?

01:31.000 --> 01:34.000
Okay, let's get it out of the plate.

01:34.000 --> 01:39.000
So, okay, I'm really happy that the others will be able to discover it.

01:39.000 --> 01:45.000
So, Open Layers, it's a JavaScript library for doing interactive maps on the web.

01:45.000 --> 01:48.000
There's other open source libraries around.

01:48.000 --> 01:53.000
It's the main open source libraries are leaflets, map library, and open layers.

01:53.000 --> 01:55.000
But the Open Layers have been around for a long time.

01:55.000 --> 01:58.000
The first version was out in 2006, actually I checked.

01:58.000 --> 02:02.000
It was rewritten from scratch in 2013,

02:02.000 --> 02:05.000
and it's constantly evolving and improving,

02:05.000 --> 02:07.000
and I think that's really important.

02:07.000 --> 02:10.000
The codebase is very healthy, it's kept up to date.

02:10.000 --> 02:14.000
It's very well tested, also, which is important.

02:15.000 --> 02:19.000
You can use it by doing npm install oil, so it's an npm package,

02:19.000 --> 02:22.000
and come back to that a bit later.

02:22.000 --> 02:25.000
Quick screenshot of the GitHub repository.

02:25.000 --> 02:29.000
So, the website, the code source is hosted on GitHub,

02:29.000 --> 02:32.000
Open Layers, slash Open Layers.

02:32.000 --> 02:34.000
And you can see here, there's...

02:34.000 --> 02:37.000
So, it's been around for a while, so we have a lot of stars,

02:37.000 --> 02:40.000
it's a bit of a vanity metric, a lot of commits.

02:41.000 --> 02:44.000
The license is BSD2 class.

02:44.000 --> 02:47.000
We have almost 90 open per request.

02:47.000 --> 02:49.000
So, this number is increasing, that's time.

02:49.000 --> 02:53.000
I just talked about half of that, so the community is active,

02:53.000 --> 02:56.000
but there's more, I guess it's a growing interest in it.

02:56.000 --> 02:59.000
So, it's good, but it's a little catch up.

02:59.000 --> 03:05.000
So, Open Layers has the reputation to be quite big library.

03:05.000 --> 03:09.000
Probably people have called it bloated at times.

03:09.000 --> 03:13.000
The important part, the important thing to understand is that

03:13.000 --> 03:17.000
Open Layers, every feature is placed into separate modules.

03:17.000 --> 03:20.000
So, you know, there's just one package, which is,

03:20.000 --> 03:23.000
I think, a package, which is oil,

03:23.000 --> 03:26.000
but if you only import the features that you need,

03:26.000 --> 03:28.000
it won't have too much of a burden on your code.

03:28.000 --> 03:30.000
That's really important.

03:30.000 --> 03:33.000
I mean, there should be three shaking happening.

03:33.000 --> 03:37.000
So, if you don't use all of it, it can actually be quite light.

03:38.000 --> 03:41.000
And the reason for this is that contrary to leaflight, for example,

03:41.000 --> 03:46.000
Open Layers does not expect you to rely too much on a plugging ecosystem.

03:46.000 --> 03:50.000
There are extensions and plug-ins out there, and some of them are really good,

03:50.000 --> 03:55.000
but the library is thought to have all the main features inside

03:55.000 --> 04:01.000
and maintained in the core code at the same level of quality.

04:01.000 --> 04:05.000
Let's look at some stuff that we can do with the library.

04:05.000 --> 04:07.000
I want to cover a few topics.

04:07.000 --> 04:11.000
I won't have too much time to dive too deep.

04:11.000 --> 04:15.000
So, I'll just cover a few stuff, and then you can look for yourself afterwards.

04:15.000 --> 04:18.000
Vector data, oh, that looks, that works.

04:18.000 --> 04:20.000
So, you can see here, this is an example,

04:20.000 --> 04:23.000
a basic vector layer example.

04:23.000 --> 04:26.000
This is a big geogation data set of the world.

04:26.000 --> 04:30.000
And I can pan around zoom in zoom out, works great.

04:30.000 --> 04:34.000
This example actually used the WebGA renderer.

04:34.000 --> 04:38.000
The way we define styles in Open Layers.

04:38.000 --> 04:40.000
So, I want to talk a bit about this.

04:40.000 --> 04:43.000
If you used Open Layers, maybe a few years ago,

04:43.000 --> 04:47.000
you might have used the mainstream styling API,

04:47.000 --> 04:49.000
which where you instantiate style objects,

04:49.000 --> 04:51.000
and it's very valuable, it's quite complicated.

04:51.000 --> 04:55.000
I also utilize a lot on style functions.

04:55.000 --> 04:59.000
We introduced a couple of years ago,

04:59.000 --> 05:02.000
I think, the concept of expression-based styling.

05:02.000 --> 05:05.000
So, instead of defining its complex styling objects

05:05.000 --> 05:08.000
and functions that are evaluated all the time,

05:08.000 --> 05:12.000
you can just give it a set of rules of styling rules.

05:12.000 --> 05:15.000
And I hope this is readable, maybe not that much,

05:15.000 --> 05:21.000
but so, each rule has a filter and style properties.

05:21.000 --> 05:24.000
So, the filter lets you select which objects

05:24.000 --> 05:26.000
will be affected by that rule,

05:26.000 --> 05:30.000
and then the style properties will be for these objects.

05:30.000 --> 05:33.000
This is very important move,

05:33.000 --> 05:37.000
and we really recommend people to use that.

05:37.000 --> 05:40.000
And a very important part of this is that filters

05:40.000 --> 05:44.000
and style properties can be, so here it's just a color,

05:44.000 --> 05:48.000
but you can also have expressions,

05:48.000 --> 05:52.000
so expressions for filters and for style properties.

05:52.000 --> 05:56.000
And this way, you don't have to rely on style functions anymore.

05:56.000 --> 05:59.000
You can define the style using these expressions.

05:59.000 --> 06:02.000
It's a very powerful system.

06:02.000 --> 06:05.000
It's not very easy to use at first.

06:05.000 --> 06:09.000
We actually got most of the inspiration for the map library,

06:09.000 --> 06:13.000
a style specification, which also use these kind of expressions.

06:13.000 --> 06:16.000
If you use these kind of styling,

06:16.000 --> 06:19.000
you will be able to have better performance.

06:19.000 --> 06:22.000
For instance, if you want to use WebJair rendering,

06:22.000 --> 06:25.000
you have to use these, you can choose style functions.

06:25.000 --> 06:28.000
This is another example of vector data using WebJair,

06:28.000 --> 06:35.000
and you can see here, we apply a filter that actually changes along the line,

06:35.000 --> 06:37.000
according to values along the line.

06:37.000 --> 06:40.000
So we can change the filter dynamically,

06:40.000 --> 06:42.000
and then have the lines randomly differently.

06:42.000 --> 06:44.000
We also have colors changing along the line.

06:44.000 --> 06:47.000
I think it's a very interesting example of what we can do

06:47.000 --> 06:52.000
with this style expressions, which we couldn't do before.

06:52.000 --> 06:56.000
Vector data, you can also render it using clusters.

06:56.000 --> 06:57.000
It's pretty good.

06:57.000 --> 07:00.000
You have also a heat map.

07:00.000 --> 07:04.000
And then let's move on to type data.

07:04.000 --> 07:07.000
So, open yours, loves type data.

07:07.000 --> 07:10.000
Obviously it's very efficient for rendering.

07:10.000 --> 07:14.000
It comes in many different types and shapes.

07:14.000 --> 07:17.000
The most simple type data is image size.

07:17.000 --> 07:19.000
So you can see here, you have a map size,

07:19.000 --> 07:22.000
come from IGN in France.

07:22.000 --> 07:25.000
So, open yours, we'll just load the ties at the correct zoom level,

07:25.000 --> 07:29.000
and stitch them together, and that's all working well.

07:29.000 --> 07:33.000
Here, you have an example that shows vector ties.

07:33.000 --> 07:36.000
So, same principle, here the vector ties,

07:36.000 --> 07:40.000
sort of being images are, you know, bunches of geometry isn't them.

07:41.000 --> 07:43.000
And here they're not tied.

07:43.000 --> 07:46.000
So you can see kind of what's looking,

07:46.000 --> 07:48.000
how it looks inside the vector tie.

07:48.000 --> 07:52.000
But most of the time, you would want to tie them, obviously.

07:52.000 --> 07:57.000
Open errors has a lot of logic for loading ties,

07:57.000 --> 08:00.000
you know, the right ties at the right time.

08:00.000 --> 08:02.000
And you can see here, there's an animation,

08:02.000 --> 08:06.000
and I'm moving, animating the view from a burnt brothels.

08:06.000 --> 08:08.000
And why the view is animating, you know,

08:08.000 --> 08:11.000
the ties that are shown change along the way,

08:11.000 --> 08:15.000
and the pioneers try to find the best tie for the best zoom level,

08:15.000 --> 08:19.000
so that the map stays crisp and readable.

08:19.000 --> 08:23.000
There's a tie queue system, you can change the side of the tie cage.

08:23.000 --> 08:26.000
This is all very elaborate.

08:26.000 --> 08:31.000
Tie data is distributed across the categories,

08:31.000 --> 08:33.000
and I just want to mention this,

08:33.000 --> 08:36.000
because oftentimes we see ties on the web mechanism,

08:36.000 --> 08:39.000
which is a total tie grid, right, the world is square,

08:39.000 --> 08:41.000
and we split it by two and two.

08:41.000 --> 08:43.000
But a tie grid can be anything,

08:43.000 --> 08:45.000
it can be different projections,

08:45.000 --> 08:47.000
it can be just over a certain area,

08:47.000 --> 08:52.000
and the operators has no assumption of the tie grid that you use.

08:52.000 --> 08:57.000
Operators also will handle devices with higher pixel density.

08:57.000 --> 08:59.000
So typically mobile devices,

08:59.000 --> 09:02.000
how can I have like two, three, four, and more DPI's.

09:02.000 --> 09:05.000
And then the library will try and load the right ties,

09:05.000 --> 09:07.000
you know, use the higher quality ties,

09:07.000 --> 09:09.000
it's available, and it's kind of things.

09:09.000 --> 09:13.000
Again, so that it stays very crisp on your screen.

09:13.000 --> 09:17.000
Vector ties also have decluttering applied to them.

09:17.000 --> 09:20.000
So typically if you have vector ties with the labels,

09:20.000 --> 09:24.000
you might not want to show all the labels at the same time,

09:24.000 --> 09:25.000
because they will be unreadable.

09:25.000 --> 09:27.000
So decluttering happens,

09:27.000 --> 09:29.000
and this is also a very elaborate system

09:29.000 --> 09:32.000
where you can change a lot of things.

09:33.000 --> 09:35.000
Rusted data.

09:35.000 --> 09:39.000
So Rusted data typically comes from satellite imagery,

09:39.000 --> 09:42.000
also like draw on other kind of photography.

09:42.000 --> 09:44.000
And what you can do in open areas,

09:44.000 --> 09:48.000
you can actually, you can give the library raw Rusted data

09:48.000 --> 09:51.000
and render it in different ways.

09:51.000 --> 09:53.000
Here we use a geotip file,

09:53.000 --> 09:57.000
and then we compute on the fly the NDVI,

09:57.000 --> 09:59.000
so the normalized difference.

10:00.000 --> 10:03.000
And to do that, we use again an expression.

10:03.000 --> 10:05.000
So here you can see,

10:05.000 --> 10:09.000
we're creating a tie layer, which is for image ties.

10:09.000 --> 10:13.000
And this tie, instead of being for vector data,

10:13.000 --> 10:16.000
it just has a color property,

10:16.000 --> 10:18.000
and here we give it an expression.

10:18.000 --> 10:20.000
And this expression computes NDVI,

10:20.000 --> 10:21.000
NDVI, and the WI,

10:21.000 --> 10:24.000
and assigns it to the different channels.

10:24.000 --> 10:25.000
This is all done.

10:25.000 --> 10:27.000
This is all done on the client, right?

10:28.000 --> 10:31.000
And that means that you can just decide,

10:31.000 --> 10:33.000
you know, give the raw data to open areas

10:33.000 --> 10:35.000
and decide how to render it.

10:35.000 --> 10:40.000
For example, here this data comes from Sentinel2.

10:40.000 --> 10:43.000
Here we're just assigning the visible color bands

10:43.000 --> 10:45.000
to the color channels, right?

10:45.000 --> 10:48.000
So red bands goes to random, et cetera.

10:48.000 --> 10:50.000
But we can also switch the styling

10:50.000 --> 10:53.000
and have the red channel be the infrared band,

10:53.000 --> 10:56.000
and the other channels be something else.

10:56.000 --> 10:58.000
And then you can again, on the fly,

10:58.000 --> 11:02.000
you can just change the way the data is showing on a map.

11:04.000 --> 11:08.000
Open layers has a support for many different kinds of protections.

11:08.000 --> 11:11.000
This is also very important in the library.

11:11.000 --> 11:14.000
When you create a map by default,

11:14.000 --> 11:15.000
it's going to be web macator,

11:15.000 --> 11:17.000
it's like a sensible default.

11:17.000 --> 11:19.000
But you can give it really anything

11:19.000 --> 11:21.000
that's supported by Prosh for.

11:21.000 --> 11:23.000
And here, for example, this is the map of the world

11:23.000 --> 11:25.000
using mall-vider projection.

11:25.000 --> 11:27.000
You can have many other curve projections.

11:27.000 --> 11:31.000
You can have polar projections and this curve things.

11:31.000 --> 11:33.000
And this is very important also.

11:33.000 --> 11:35.000
I want to emphasize in open layers.

11:35.000 --> 11:38.000
You have the concept of the view projection, right?

11:38.000 --> 11:42.000
You decide what, how your map will be rendered

11:42.000 --> 11:44.000
with which projection.

11:44.000 --> 11:46.000
But you also have the projection of your data.

11:46.000 --> 11:49.000
So if your data comes from a different projection,

11:49.000 --> 11:51.000
an open layers will mostly,

11:51.000 --> 11:54.000
most likely be able to convert it on the fly.

11:54.000 --> 11:57.000
If it's vector data, it will transform the curve vector coordinates.

11:57.000 --> 11:59.000
And if it's raster data,

11:59.000 --> 12:02.000
it will also be able to distort the images

12:02.000 --> 12:04.000
so that it matches the projection.

12:04.000 --> 12:09.000
Right. Another addition that was done

12:09.000 --> 12:12.000
pretty recently, that's recall, it's a flow layer.

12:12.000 --> 12:14.000
So it's a web-gear rendered layer.

12:14.000 --> 12:17.000
You can give it a grid of values

12:17.000 --> 12:19.000
typically coming from a weather data.

12:19.000 --> 12:22.000
And then the layer will interpolate between those values

12:22.000 --> 12:24.000
and then make a field out of it.

12:24.000 --> 12:27.000
And then simulate particles going over it.

12:27.000 --> 12:29.000
It's pretty common visualizations,

12:29.000 --> 12:32.000
but no, it's built in the library.

12:34.000 --> 12:37.000
You can have many different formats in open layers.

12:37.000 --> 12:40.000
Just a quick list.

12:40.000 --> 12:42.000
Yeah, anywhere.

12:42.000 --> 12:44.000
I'm just going to spend some time on this.

12:44.000 --> 12:46.000
There's many different sources.

12:46.000 --> 12:49.000
Operators knows about OGC API standards.

12:49.000 --> 12:51.000
So map and vector ties.

12:51.000 --> 12:54.000
Classic OGC protocols, WMS, et cetera.

12:54.000 --> 12:57.000
Sentinel hub also is a source now.

12:57.000 --> 12:58.000
Pianties.

12:58.000 --> 13:01.000
You can use Google Maps if you have a key.

13:01.000 --> 13:03.000
Stay the maps.

13:03.000 --> 13:06.000
Cloud Optimized Geotif is also a data source.

13:06.000 --> 13:08.000
The way it works is when you create a layer.

13:08.000 --> 13:10.000
You have to assign it to source, right?

13:10.000 --> 13:12.000
You have different kind of layers, different kind of source.

13:12.000 --> 13:15.000
And you kind of make that work together.

13:15.000 --> 13:18.000
I'm not going to have different control interactions.

13:18.000 --> 13:21.000
Again, I'm not going to spend too much time on this.

13:21.000 --> 13:24.000
Classic to draw interaction, select, modify.

13:24.000 --> 13:27.000
You can rotate the view, full screen, scale bar,

13:27.000 --> 13:31.000
double gratical, and these kind of things.

13:31.000 --> 13:34.000
This is an example of a draw interaction.

13:34.000 --> 13:38.000
That uses tracing, which I think it's really nice.

13:38.000 --> 13:41.000
So you see here, you're going to draw a shape.

13:41.000 --> 13:46.000
And I think that would be cool to draw a draw.

13:46.000 --> 13:49.000
And then you will have this kind of snapping

13:49.000 --> 13:51.000
where it will follow a shape.

13:51.000 --> 13:54.000
And that's really useful if you have complex shapes.

13:54.000 --> 13:58.000
This is also something that the draw interaction can do for you.

13:58.000 --> 14:01.000
Operators has first class mobile support.

14:01.000 --> 14:03.000
So I talked about pixel density.

14:03.000 --> 14:06.000
But also like when you create a map by default,

14:06.000 --> 14:08.000
you will work on mobile.

14:08.000 --> 14:10.000
So you can interact with the fingers.

14:10.000 --> 14:12.000
You can zoom in, zoom out.

14:12.000 --> 14:14.000
You can rotate them up and stuff things.

14:14.000 --> 14:18.000
It's really first class support.

14:18.000 --> 14:21.000
How to use the library?

14:21.000 --> 14:24.000
So this is what it looks like.

14:24.000 --> 14:27.000
Create a map.

14:27.000 --> 14:31.000
It's just a pretty simple example.

14:31.000 --> 14:35.000
And actually, most of it will be much more complex than that.

14:35.000 --> 14:37.000
You just do the general concept.

14:37.000 --> 14:39.000
You have a map which contains layers.

14:39.000 --> 14:41.000
Layers have sources.

14:41.000 --> 14:43.000
And then a map has a view.

14:43.000 --> 14:45.000
The view lets you center on objects.

14:45.000 --> 14:47.000
The view are very useful functions.

14:47.000 --> 14:49.000
If you want to center on an object.

14:49.000 --> 14:50.000
If you want to animate the view.

14:50.000 --> 14:51.000
Compute an extent.

14:51.000 --> 14:53.000
And this kind of things.

14:53.000 --> 14:55.000
And then you set up controls.

14:55.000 --> 14:57.000
And interactions.

14:57.000 --> 15:01.000
The NPM package is called OEL.

15:01.000 --> 15:04.000
It comes with type definitions.

15:04.000 --> 15:06.000
So openness is written in JavaScript.

15:06.000 --> 15:08.000
But it has JS documentation.

15:08.000 --> 15:10.000
So it's a type library.

15:10.000 --> 15:14.000
And you get type free support.

15:14.000 --> 15:18.000
If you use NPM style while we get the latest table version.

15:18.000 --> 15:20.000
You can use a dev.

15:20.000 --> 15:22.000
If you want to have the latest version on main.

15:22.000 --> 15:24.000
That can be really useful.

15:24.000 --> 15:27.000
If the features have not been released yet.

15:27.000 --> 15:30.000
The main version is really very stable.

15:30.000 --> 15:32.000
That might be a few bugs.

15:32.000 --> 15:34.000
But that haven't been fixed yet.

15:34.000 --> 15:36.000
Or breaking changes.

15:36.000 --> 15:38.000
But most of the time you get to go.

15:38.000 --> 15:42.000
That's a very extensive example.

15:42.000 --> 15:44.000
List on the website.

15:44.000 --> 15:46.000
So openness.org.

15:46.000 --> 15:48.000
And latest examples.

15:48.000 --> 15:52.000
I usually suggest people to start with this.

15:52.000 --> 15:56.000
It's a very, yeah, it's like 258 examples.

15:56.000 --> 15:58.000
There's an example for almost every feature.

15:58.000 --> 16:00.000
And if you're not sure if the library can do something.

16:00.000 --> 16:04.000
Or what it looks like when it runs, then just take a look at the example.

16:04.000 --> 16:06.000
And you should have your answers.

16:06.000 --> 16:10.000
There's an API doc as well.

16:10.000 --> 16:12.000
Recently, we came up with something interesting.

16:12.000 --> 16:16.000
We created a website for doing benchmarks.

16:16.000 --> 16:21.000
And that's because in the past year and a half sort of we tried.

16:21.000 --> 16:25.000
Improving the performance of vector data rendering.

16:25.000 --> 16:29.000
As much as possible, we invested a lot of time and energy in this.

16:29.000 --> 16:33.000
And together, an idea of how good the library was getting.

16:33.000 --> 16:35.000
We came up with these benchmarks.

16:35.000 --> 16:38.000
So these benchmarks have different cases, right?

16:38.000 --> 16:40.000
Rendering polygons, rendering lines, etc.

16:40.000 --> 16:42.000
Rendering vector ties.

16:42.000 --> 16:47.000
And for each case, you have like these shapes showing up.

16:47.000 --> 16:49.000
And you can change all the parameters.

16:49.000 --> 16:51.000
And increase the number of shapes.

16:51.000 --> 16:54.000
And see how far you can push the library.

16:54.000 --> 16:58.000
And by doing this, we try and find the soft limits of the library.

16:58.000 --> 17:01.000
And that's a very good indication of, you know,

17:01.000 --> 17:05.000
should we improve this part of the rendering further or not.

17:05.000 --> 17:07.000
You can switch from WebJair.

17:07.000 --> 17:11.000
You can switch on or of WebJair rendering.

17:11.000 --> 17:14.000
And you can also, there's a performance tracker,

17:14.000 --> 17:18.000
which lets you give you an idea of what's going on at each frame.

17:18.000 --> 17:25.000
And this is, I mean, this is very interesting for us when you try to improve the performance.

17:25.000 --> 17:26.000
But I think it's also interesting.

17:26.000 --> 17:31.000
You can take a look at it if you want to have an idea of how the library runs.

17:31.000 --> 17:33.000
And what performance you can expect from it.

17:33.000 --> 17:36.000
So the website is open.org-bench.

17:36.000 --> 17:40.000
And you can also change what would different pass versions

17:40.000 --> 17:43.000
and see how the effects that's pretty cool.

17:43.000 --> 17:47.000
So we worked it out on the performance of vector data.

17:47.000 --> 17:52.000
And that's mostly done through WebJair rendering, which I talked a little bit.

17:53.000 --> 17:58.000
Just a few words to say why I think this project is important

17:58.000 --> 18:01.000
and why I care about it very much.

18:01.000 --> 18:06.000
So I mentioned the other open source libraries, my library and leaflet.

18:06.000 --> 18:11.000
I think each library has their strong points and weaknesses.

18:11.000 --> 18:14.000
The thing is, opening it is really, it's not easy to use.

18:14.000 --> 18:18.000
I mean, it has a bit of a complexity, but you can do, you know,

18:18.000 --> 18:20.000
really, pretty much anything.

18:20.000 --> 18:24.000
It can throw pretty much anything at it and it will render it.

18:24.000 --> 18:27.000
It's completely agnostic to the source providers,

18:27.000 --> 18:30.000
data providers, you know, the kind of data,

18:30.000 --> 18:34.000
can be tied data or not, many different formats and projects.

18:34.000 --> 18:36.000
The project is not owned by a company.

18:36.000 --> 18:39.000
It's a true community project.

18:39.000 --> 18:43.000
And I have to say, it's a very neutral project.

18:43.000 --> 18:46.000
Because, you know, there's no assumption about anything.

18:47.000 --> 18:49.000
So, yeah, I said, like Western assumptions,

18:49.000 --> 18:53.000
because you can use it in different projections, different parts of the world.

18:53.000 --> 18:57.000
We have regularly Chinese users, I think showing up at the GitHub,

18:57.000 --> 19:00.000
which makes communication a bit hard,

19:00.000 --> 19:03.000
but I think that's a very interesting thing.

19:03.000 --> 19:07.000
Also, a good example is text rendering on the map,

19:07.000 --> 19:11.000
because we rely on the text rendering of the browser.

19:11.000 --> 19:13.000
It means that text can be anything.

19:13.000 --> 19:16.000
It doesn't have to be our alphabet, can be right to left.

19:16.000 --> 19:20.000
You can be different characters and these all works really well.

19:20.000 --> 19:26.000
So, yeah, so just a quick word to say that,

19:26.000 --> 19:29.000
if you want to help, you welcome, you know,

19:29.000 --> 19:30.000
go to GitHub.

19:30.000 --> 19:31.000
You can try it out.

19:31.000 --> 19:33.000
If you find a bug, please report it.

19:33.000 --> 19:36.000
And if you want to try your candidate, please try and open the poor request.

19:36.000 --> 19:38.000
And people will help you out.

19:38.000 --> 19:40.000
No worries.

19:41.000 --> 19:43.000
Yeah, that's it. Time for questions.

19:59.000 --> 20:00.000
Okay.

20:06.000 --> 20:09.000
Okay, so you put requests when was it opened?

20:10.000 --> 20:12.000
Before what?

20:12.000 --> 20:13.000
Okay.

20:13.000 --> 20:14.000
Right.

20:14.000 --> 20:19.000
So, also, keep in mind that people sometimes use their own time to work on this.

20:19.000 --> 20:23.000
So, you know, basically what you try and do is say,

20:23.000 --> 20:27.000
yeah, okay, I'll have to get it.

20:27.000 --> 20:29.000
I can, I can, I can, yeah.

20:29.000 --> 20:30.000
It's very great.

20:31.000 --> 20:32.000
Yeah.

20:36.000 --> 20:40.000
You're saying, like, obviously, open this has a lot of functions.

20:40.000 --> 20:45.000
And maybe, or like, in reference to something like,

20:45.000 --> 20:47.000
if there's a lot of stuff that she's been saying,

20:47.000 --> 20:49.000
directly to open this.

20:49.000 --> 20:50.000
Right.

20:50.000 --> 20:53.000
How to, like, the main thing is to size, like,

20:53.000 --> 20:58.000
what to, what should be included in the poor library and what to, like,

20:58.000 --> 21:02.000
you know, potentially popular to, like, a bug game or just some external credit,

21:02.000 --> 21:03.000
like, it's there.

21:03.000 --> 21:07.000
Is it, how does that discussion happen?

21:07.000 --> 21:10.000
So, the question is, how do maintenance decide what gets,

21:10.000 --> 21:16.000
put inside the library or what maybe is left for other plugins to do?

21:16.000 --> 21:18.000
I think the library tries to have as many,

21:18.000 --> 21:21.000
200 as many providers and formats as possible.

21:21.000 --> 21:23.000
So, you know, if there's something coming up,

21:23.000 --> 21:26.000
and, for example, the OGC API standards, then, you know,

21:26.000 --> 21:29.000
they became more stable and then they were supported in the library.

21:29.000 --> 21:32.000
When it comes to functionality, more like high level stuff,

21:32.000 --> 21:35.000
like interactions or complex drawing, things, for example,

21:35.000 --> 21:38.000
then usually it will be like, maybe, you know,

21:38.000 --> 21:42.000
people can do that in other extensions or in their application code.

21:42.000 --> 21:46.000
The interaction stuff stays quite low level, I would say.

21:46.000 --> 21:51.000
Yes?

21:51.000 --> 21:54.000
So, how is the interaction done?

21:54.000 --> 21:57.000
Is it only, like, going with the logic cable,

21:57.000 --> 22:00.000
can you create a piece of the coordinates to,

22:00.000 --> 22:03.000
and go by?

22:03.000 --> 22:06.000
Okay, the question is about drawing, right?

22:06.000 --> 22:08.000
The drawing interaction, how can you,

22:08.000 --> 22:11.000
so the default drawing interaction, again,

22:11.000 --> 22:14.000
you can click, set a vertex at every click.

22:14.000 --> 22:16.000
You also have a free-hand mode,

22:16.000 --> 22:19.000
but you can also programmatically push coordinates.

22:19.000 --> 22:21.000
And that's what we do in the trading stuff, right?

22:21.000 --> 22:26.000
When you snap to a polygon, then we push coordinates without clicking.

22:26.000 --> 22:31.000
If I have a map that I just want to eat it today,

22:31.000 --> 22:36.000
if I want to, if I want to trap objects on a map,

22:36.000 --> 22:39.000
right?

22:39.000 --> 22:41.000
I don't know, probably not, like, okay,

22:41.000 --> 22:44.000
so if you want to feel your map with data,

22:44.000 --> 22:47.000
you don't need to do, like, interaction is really when it comes to,

22:47.000 --> 22:49.000
like, the user doing something,

22:49.000 --> 22:52.000
but if it programmatically, you want to push objects in your map,

22:52.000 --> 22:54.000
then you don't need interactions.

22:54.000 --> 22:57.000
You basically push data on your source at the source level,

22:57.000 --> 23:00.000
and then it shows up on them.

23:00.000 --> 23:02.000
Yeah?

23:02.000 --> 23:07.000
Can you share about how you do performance testing on mobile devices,

23:07.000 --> 23:11.000
like, constraints in CPU, RAM, or, in cases of,

23:11.000 --> 23:16.000
like, that network, or, you know, a critical out, you far away,

23:16.000 --> 23:18.000
or, like, how do you do that?

23:18.000 --> 23:21.000
Okay, so about performance on mobile.

23:21.000 --> 23:24.000
So network, you can do a flying stuff with open layers,

23:24.000 --> 23:26.000
but it's not really handled by the library.

23:26.000 --> 23:29.000
You know, if you push the data into its source,

23:29.000 --> 23:34.000
if you're offline, or online, actually the library doesn't really care.

23:35.000 --> 23:38.000
The library tries to be as light as possible on battery.

23:38.000 --> 23:41.000
This benchmark website is also,

23:41.000 --> 23:44.000
it can also be used to test stuff on mobile.

23:44.000 --> 23:47.000
So, yeah, basically, yeah.

23:47.000 --> 23:49.000
But, I mean, for a long time, we just,

23:49.000 --> 23:51.000
we don't have any problem metrics, right?

23:51.000 --> 23:53.000
We will just try and stuff, you know,

23:53.000 --> 23:55.000
like, try the examples on your mobile,

23:55.000 --> 23:58.000
or use a simulator or something.

23:58.000 --> 24:01.000
But, no, we try to have better metrics.

24:02.000 --> 24:03.000
Oh, no.

24:08.000 --> 24:09.000
Okay.