Créer une belle carte qui véhicule efficacement son message n’est pas chose facile. On dispose souvent d’une grande quantité de données qu’on ne souhaite pas afficher en tout temps ou qu’on souhaite afficher mais avec un style qui varie en fonction du niveau d’échelle. Lorsqu’on définit le style d’une carte, chaque petit détail est important. Le processus se fait généralement de facon itérative et implique beaucoup de modifications, à tous les niveaux d’échelle.

Dans MapServer, la gestion de l’échelle se fait avec les tags MINSCALEDENOM et MAXSCALEDENOM au niveau du LAYER ou de la CLASS. Cela veut dire qu’aussitôt qu’un élément du style change pour un LAYER ou une CLASS donné, à un certain niveau d’échelle, un nouveau LAYER ou une nouvelle CLASS doit être créé. On se trouve ainsi a réécrire beaucoup de texte pour ne modifier peut-être qu’un seul paramètre. La tâche devient encore plus fastidieuse si on doit changer un paramètre (par exemple la couleur d’une route) définie dans 16 LAYERs différents.

C’est à ce moment que Scribe vient à votre rescousse. Il s’agit d’un outil écrit en python que nous avons développé pour faciliter l’écriture d’un ‘mapfile’ en utilisant des variables et des raccourcis pour la gestion des échelles via des niveaux (maintenant la norme). Cette façon de faire s’apparente à Basemaps mais est plus simple d’utilisation et généralement moins verbeuse.

Gestion des niveaux d’échelle


LAYER {
    1-16 {
        NAME: 'land'
        TYPE: POLYGON
        @layerconfig
        DATA {
            1-4: '110m_physical/ne_110m_land'
            5-10: '50m_physical/ne_50m_land'
            11-16: '10m_physical/ne_10m_land'
        }
        CLASS {
            STYLE {
                COLOR {
                    1-6: '#EEECDF'
                    7-16: '#AAA89B'
                }
                OUTLINECOLOR: 200 200 200
                OUTLINEWIDTH: @land_ol_width
            }
        }
    }
}
 

Dans l’exemple précédent, un LAYER appelé ‘land’ est créé. Le tag ‘1-16’ signifie que ce LAYER doit etre affiché des niveaux d’échelle 1 à 16. Le script traduit automatiquement ces niveaux en MINSCALEDENOM et MAXSCALEDENOM. De plus, les données utilisées (DATA) des niveaux 1 à 4 sont au 110m tandis qu’elles sont au 50m des niveaux 5 à 10 et au 10m des niveaux 11 à 16. La couleur (COLOR) elle aussi change en fonction de l’échelle. En utilisant cette nomenclature, il devient très facile de modifier un paramètre pour un ou plusieurs niveaux d’échelle sans avoir à réécrire beaucoup de texte ou à faire des modifications à plusieurs endroits.

Définition et utilisation de variables

Scribe ne permet pas seulement de gérer les échelles mais il permet aussi de définir des variables réutilisables. Dans l’exemple ci-haut, les variables ‘layerconfig’ et ‘land_ol_width’ sont appelées a l’aide d’un ‘@’. Ces variables sont définies de la facon suivante:


VARIABLES {
    layerconfig {
        GROUP: 'default'
        STATUS: ON
        PROJECTION {{
            'init=epsg:4326'
        }}
        PROCESSING: 'LABEL_NO_CLIP=ON'
        PROCESSING: 'CLOSE_CONNECTION=DEFER'
    }
    land_ol_width: 1
}

La variable ‘layerconfig’ contient plusieurs paramètres utilisés dans la définition de presque tous les LAYERs. Ainsi, pour chaque nouveau LAYER, il suffit d’écrire ‘@layerconfig’ pour que tous les paramètres entrent dans la définition du LAYER. L’autre variable ‘land_ol_width’ prend une valeur unique.

Il est à noter que dans la définition de la variable ‘layerconfig’, PROJECTION est suivi de deux ‘{‘. Cette syntaxe permet de gérer les tags comme PROJECTION, METADATA, PATTERN etc qui ne contiennent aucun paramètre, seulement du texte.

Blocs de commentaires


LAYER {
    1-16 {
        NAME: 'land'
        TYPE: POLYGON
        @layerconfig
        DATA {
            1-4: '110m_physical/ne_110m_land'
            5-10: '50m_physical/ne_50m_land'
            11-16: '10m_physical/ne_10m_land'
        }
        CLASS {
            STYLE {
                COLOR {
                    1-6: '#EEECDF'
                    7-16: '#AAA89B'
                }
                ##Les commentaires précédés par ## apparaissent
                ##dans le mapfile résultant.
                ##Les blocs de commentaires entre /* */
                ## n'apparaissent pas dans le mapfile résultant.
                /* 
                OUTLINECOLOR: 200 200 200
                OUTLINEWIDTH: @land_ol_width
                */              
            }
        }
    }
}

Éxécuter le script

Finalement, pour exécuter le script, il suffit d’utiliser une seule commande, configurable avec certaines options:


python scribe.py

Le résultat est un mapfile parfaitement indenté avec gestion des échelles et souvent beaucoup plus de ligne que ce qu’il a fallu écrire. Scribe représente donc une économie importante en temps et produire des cartes de qualité devient plus facile et agréable.

Suivre Scribe sur GitHub

Scribe est un produit en évolution auquel de nouvelles fonctionnalités s’ajouteront. Nous vous invitons à suivre ses progrès ainsi qu’à l’utiliser en visitant son dépot GitHub. Si vous avez besoin de plus d’informations, veuillez nous contacter.

NOTE: cet article a été publié à l’origine sur le blogue de Simon Mercier