File: tutorial.rst

package info (click to toggle)
mapproxy 1.9.0-2~bpo8%2B1
  • links: PTS, VCS
  • area: main
  • in suites: jessie-backports
  • size: 6,148 kB
  • sloc: python: 33,246; xml: 6,257; makefile: 194
file content (429 lines) | stat: -rw-r--r-- 15,008 bytes parent folder | download | duplicates (7)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
Tutorial
########

This tutorial should give you a quick introduction to the MapProxy configuration.

You should have a :doc:`working MapProxy installation <install>`, if you want to follow this tutorial.

Configuration format
====================

The configuration of MapProxy uses the YAML format. YAML is a superset of JSON. That means every valid
JSON is also valid YAML. MapProxy uses no advanced features of YAML, so you could
even use JSON. YAML uses a more readable and user-friendly syntax. We encourage
you to use it.

If you are familiar with YAML you can skip to the next section.

The YAML configuration consist of comments, dictionaries, lists, strings, numbers
and booleans.

Comments
--------
Everything after a hash character (``#``) is a comment and will be ignored.

Numbers
-------
Any numerical value like ``12``, ``-4``, ``0``, and ``3.1415``.

Strings
-------
Any string within single or double quotes. You can omit the quotes if the string
has no other meaning in YAML syntax. For example::

    'foo'
    foo
    '43' # with quotes, otherwise it would be numeric
    '[string, not a list]'
    A string with spaces and punctuation.

Booleans
--------
True or false values::

    yes
    true
    True
    no
    false
    False


List
----
A list is a collection of other valid objects. There are two formats. The condensed
form uses square brackets::

    [1, 2, 3]
    [42, string, [another list with a string]]


The block form requires every list item on a separate line, starting with
``-`` (dash and a blank)::

    - 1
    - 2
    - 3

    - 42
    - string
    - [another list]

Dictionaries
------------
A dictionary maps keys to values. Values itself can be any valid object.

There are two formats. The condensed form uses braces::

  {foo: 3, bar: baz}

The block form requires every key value pair on a seperate line::

    foo: 3
    bar: baz


You can also nest dictionaries. Each nested dictionary needs to be indented by one or more whitespaces. Tabs are *not* permitted and all keys to the same dictionary need to be indented by the same amount of spaces.

::

    baz:
      ham: 2
      spam:
        bam: True
      inside_baz: 'yepp'


Configuration Layout
====================

The MapProxy configuration is a dictionary, each key configures a different aspect
of MapProxy. There are the following keys:


- ``services``:  This is the place to activate and configure MapProxy's services
                 like WMS and TMS.

- ``layers``: Configure the layers that MapProxy offers. Each layer can consist
              of multiple sources and caches.

- ``sources``:
    Define where MapProxy can retrieve new data.

- ``caches``:
    Here you can configure the internal caches.

- ``grids``: MapProxy aligns all cached images (tiles) to a grid. Here you can define
             that grid.

- ``globals``:  Here you can define some internals of MapProxy and default values
                that are used in the other configuration directives.

The order of the directives is not important, so you can organize it your way.


Example Configuration
=====================

Configuring a Service
---------------------

At first we need to :ref:`configure at least one service <services>`. To enable
a service, you have to include its name as a key in the `services` dictionary.
For example::

  services:
    tms:


Each service is a YAML dictionary, with the service type as the key. The dictionary
can be empty, but you need to add the colon so that the configuration parser knows
it's a dictionary.


A service might accept more configuration options. The WMS service, for example,
takes a dictionary with metadata. This data is used in the capabilities documents.

Here is an example with some contact information:

.. literalinclude:: tutorial.yaml
  :end-before: #end services

`access_constraints` demonstrates how you can write a string over multiple lines,
just indent every line the same way as the first. And remember, YAML does not
accept tab characters, you must use space.

For this tutorial we add another service called `demo`. This is a demo service
that lists all configured WMS and TMS layers. You can test each layer with a
simple OpenLayers client. So our configuration file should look like::

  services:
    demo:
    wms:
      [rest of WMS configuration]

Adding a Source
----------------

Next you need to :ref:`define the source <sources>` of your data. Every source has
a name and a type. Let's add a WMS source:

.. literalinclude:: tutorial.yaml
  :prepend: sources:
  :start-after: #start source
  :end-before: #end source

In this example `test_wms` is the name of the source, you need this name later
to reference it. Most sources take more parameters – some are optional, some are
required. The type `wms` requires the `req` parameter that describes the WMS
request. You need to define at least a URL and the layer names, but you can add
more options like `transparent` or `format`.


Adding a Layer
--------------

After defining a source we can use it to :ref:`create a layer <layers_section>` for the
MapProxy WMS.

A layer requires a title, which will be used in the capabilities documents and
a source. For this layer we want to use our `test_wms` data source:

.. literalinclude:: tutorial.yaml
  :prepend: layers:
  :start-after: #start cascaded layer
  :end-before: #end cascaded layer

Now we have setuped MapProxy as cascading WMS. That means MapProxy only redirect
requests to the WMS defined in `test_wms` data source.


Starting the development server
-------------------------------

That's it for the first configuration, you can now :ref:`start MapProxy <mapproxy-util>`::


  mapproxy-util serve-develop mapproxy.yaml

You can :download:`download the configuration <yaml/simple_conf.yaml>`.


When you type `localhost:8080/demo/` in the URL of your webbrowser you should
see a demo site like shown below.

.. image:: imgs/mapproxy-demo.png

Here you can see the capabilities of your configured service and watch it in action.


Adding a Cache
--------------

To speed up the source with MapProxy we :ref:`create a cache <caches>` for this
source.

Each cache needs to know where it can get new data and how it should be cached.
We define our `test_wms` as source for the cache. MapProxy splits images in
small tiles and these tiles will be aligned to a grid. It also caches images in
different resolutions, like an image pyramid. You can define this image pyramid
in detail but we start with one of the default grid definitions of MapProxy.
`GLOBAL_GEODETIC` defines a grid that covers the whole world. It uses EPSG:4326
as the spatial reference system and aligns with the default grid and resolutions that OpenLayers
uses.

Our cache configuration should now look like:

.. literalinclude:: tutorial.yaml
  :start-after: #start caches
  :end-before: #end caches


Adding a cached Layer
---------------------

We can now use our defined cache as source for a layer. When the layer is
requested by a client, MapProxy looks in the cache for the requested data and only if
it hasn't cached the data yet, it requests the `test_wms` data source.

The layer configuration should now look like:

.. literalinclude:: tutorial.yaml
  :prepend: layers:
  :start-after: #start cached layer
  :end-before: #end cached layer

You can :download:`download the configuration <yaml/cache_conf.yaml>`.


Defining Resolutions
--------------------

By default MapProxy caches traditional power-of-two image pyramids with a default
number of cached resolutions of 20. The resolutions
between each pyramid level doubles. If you want to change this, you can do so by
:ref:`defining your own grid <grids>`. Fortunately MapProxy grids provied the
ability to inherit from an other grid. We let our grid inherit from the previously
used `GLOBAL_GEODETIC` grid and add five fixed resolutions to it.

The grid configuration should look like:

.. literalinclude:: tutorial.yaml
  :prepend: grids:
  :start-after: #start res grid
  :end-before: #end res grid

As you see, we used `base` to inherit from `GLOBAL_GEODETIC` and `res` to define
our preferred resolutions. The resolutions are always in the unit of the SRS, in
this case in degree per pixel. You can use the :ref:`MapProxy scales util <mapproxy_util_scales>`
to convert between scales and resolutions.

Instead of defining fixed resolutions, we can also define a factor that is used
to calculate the resolutions. The default value of this factor is 2, but you can
set it to each value you want. Just change `res` with `res_factor` and add your
preferred factor after it.

A magical value of `res_factor` is **sqrt2**, the square root of two. It doubles
the number of cached resolutions, so you have 40 instead of 20 available resolutions.
Every second resolution is identical to the power-of-two resolutions, so you can
use this layer not only in classic WMS clients with free zomming, but also in tile-based clients
like OpenLayers which only request in these resolutions. Look at the :ref:`configuration
examples for vector data for more information <cache_resolutions>`.

Defining a Grid
---------------

In the previous section we saw how to extend a grid to provide self defined
resolutions, but sometimes `GLOBAL_GEODETIC` grid is not useful because it covers
the whole world and we want only a part of it. So let's see how to :ref:`define our own grid <grids>`.

For this example we define a grid for Germany. We need a spatial reference system (`srs`)
that match the region of Germany and a bounding box (`bbox`) around Germany to limit
the requestable aera. To make the specification of the `bbox` a little bit easier,
we put the `bbox_srs` parameter to the grid configuration. So we can define the
`bbox` in EPSG:4326.

The `grids` configuration is a dictionary and each grid configuration is identified
by its name. We call our grid `germany` and its configuration should look like:

.. literalinclude:: tutorial.yaml
  :prepend: grids:
  :start-after: #start germany grid
  :end-before: #end germany grid

We have to replace `GLOBAL_GEODETIC` in the cache configuration with our
`germany` grid. After that MapProxy caches all data in UTM32.

MapProxy request the source in the projection of the grid. You can configure
:ref:`the supported SRS for each WMS source <supported_srs>` and MapProxy
takes care of any transformations if the `srs` of our grid is
different from the data source.

You can :download:`download the configuration <yaml/grid_conf.yaml>`.

Merging Multiple Layers
-----------------------

If you have two WMS and want to offer a single layer with data from both server,
you can combine these in one cache. MapProxy will combine the images before it stores
the tiles on disk. The sources should be defined from bottom to top and
all sources except the bottom need to be transparent.

The code below is an example for configure MapProxy to combine two WMS in one
cache and one layer:

.. literalinclude:: tutorial.yaml
  :start-after: #start combined sources
  :end-before: #end combined sources

You can :download:`download the configuration <yaml/merged_conf.yaml>`.

Coverages
---------

Sometimes you don't want to provide the full data of a WMS in a layer. With
MapProxy you can define areas where data is available or where data you are
interested in is. MapProxy provides three ways to restrict the area of available
data: Bounding boxes, polygons and OGR datasource. To keep it simple, we only
discuss bounding boxes. For more informations about the other methods take
a look at :ref:`the coverages documentation <coverages>`.
To restrict the area with a bounding box, we have to define it in the coverage
option of the data source. The listing below restricts the requestable area to
Germany:

.. literalinclude:: tutorial.yaml
  :start-after: #start coverage
  :end-before: #end coverage

As you see notation of a coverage bounding box is similar to the notation in the
grid option.


Meta Tiles and Meta Buffer
--------------------------

When you have experience with WMS in tiled clients you should know the problem
of labeling issues. MapProxy can help to resolve these issues with two methods
called :ref:`Meta Tiling <meta_tiles>` and :ref:`Meta Buffering <meta_buffer>`.

There is a :doc:`chapter on WMS labeling issues <labeling>` that discusses these options.


Seeding
-------

Configuration
~~~~~~~~~~~~~
MapProxy creates all tiles on demand. That means, only tiles requested once are
cached. Fortunately MapProxy comes with a command line script for pre-generating
all required tiles called ``mapproxy-seed``. It has its own configuration file called
``seed.yaml`` and a couple of options. We now create a config file for ``mapproxy-seed``.

As all MapProxy configuration files it's notated in YAML. The mandatory option
is ``seeds``. Here you can create multiple seeding tasks that define what should be seeded.
You can specify a list of caches for seeding with ``caches`` . The cache names
should match the names in your MapProxy configuration. If you have specified
multiple grids for one cache in your MapProxy configuration, you can select these
caches to seed. They must also comply with the caches in your MapProxy configuration.
Furthermore you can limit the levels that should be seeded. If you want to seed only
a limited area, you can use the ``coverages`` option.

In the example below, we configure ``mapproxy-seed`` to seed our previously created
cache ``test_wms_cache`` from level 6 to level 16. To show a different possibility to
define a coverage, we use a polygon file to determine the area we want to seed.

.. literalinclude:: yaml/seed.yaml

As you see in the ``coverages`` section the ``polygons`` option point to a
text file. This text file contains polygons in Well-Known-Text (WKT) form. The third option tells
``mapproxy-seed`` the ``srs`` of the WKT polygons.

You can :download:`download the configuration <yaml/seed.yaml>` and the :download:`polygon file <GM.txt>`.

Start Seeding
~~~~~~~~~~~~~

Now it's time to start seeding. ``mapproxy-seed`` has a couple
of options. We have to use options ``-s`` to define our ``seed.yaml`` and ``-f``
for our MapProxy configuration file. We also use the ``--dry-run`` option to see what
MapProxy would do, without making any actual requests to our sources. A mis-configured seeding
can take days or weeks, so you should keep an eye on the tile numbers the dry-run prints out.

Run ``mapproxy-seed`` like::

    mapproxy-seed -f mapproxy.yaml -s seed.yaml --dry-run

If you sure, that seeding works right, remove ``--dry-run``.

What's next?
------------

You should read the :doc:`configuration examples <configuration_examples>` to get a few
more ideas what MapProxy can do.

MapProxy has lots of small features that might be useful for your projects, so it is a good idea
to read the other chapters of the documentation after that.

If you have any questions? We have a `mailing list and IRC channel <http://mapproxy.org/support>`_
where you can get support.