Archive pour le mot-clef ‘TileCache’

TileCache : attention aux MetaTiles !

Jeudi 21 janvier 2010

Il est bien commode lors de la génération d’un cache tuilé avec TileCache d’utiliser le mode MetaTile permettant d’envoyer des requêtes correspondant à quelques centaines de tuiles d’un coup, qui sont ensuite redécoupées par TileCache. Cette opération est effectuée par le module PIL. Malheureusement, celui-ci et son implémentation dans TileCache ont quelques défauts qui peuvent aboutir à la dégradation des images faites en MetaTile comparativement à celles générées individuellement.

Le premier défaut concerne de JPEG. La valeur de compression à utiliser n’est pas précisée dans le code et PIL prend donc sa valeur par défaut de 75 %. L’image finale via MetaTile est donc  différente de celle issue de la source de données. Si le serveur WMS lui-même effectue une compression de 75 %, celle effectuée par PIL est vraiment de trop pour la qualité. Ce problème se règle néanmoins facilement, en changeant le code de Layer.py,en ajoutant ces deux lignes après la ligne 406 :

elif self.extension == ‘jpeg’:

subimage.save(

buffer,
self.extension,
quality=95,
optimize=True

)

Le niveau de qualité de 95 % correspond en effet à « pas de compression ». A 100 % il n’y a pas non plus de quantization des couleurs, et l’image est alors plus grosse que l’originale.
Le deuxième problème est plus embêtant. Il s’agit du format PNG-8bits, dont les palettes ne sont pas correctement restituées par PIL quand l’image a été générée en mode QUANTIZE ON. Pas de solution pour l’instant dans TileCache, malgré des tests faits avec PythonMagick plutôt que PIL. L’idée est donc d’utiliser du PNG 24bits, et de faire la quantization en post-traitement, avec pngnq par exemple et une tâche cron traitant nuitamment les fichiers créés dans la journée.

MapServer, substitution de variable et mise en cache.

Vendredi 12 juin 2009

Vous le savez sans doute, MapServer permet de réaliser du « runtime substitution », soit de la substitution dynamique de variable à l’exécution. En clair, votre requête, CGI ou WMS (ce qui revient peu ou prou au même), intègre un paramètre complémentaire dont la valeur va être interprétée au sein du fichier .map.

Pour être plus clair, imaginons que vous  cartographiez les trajets routiers effectués par des utilisateurs. Chaque utilisateur ne doit voir que ses propres trajets parce qu’on est pas chez Big Brother. En rajoutant un paramètre user_id à la requête envoyée à MapServer, on peut filtrer le contenu renvoyé par le fichier .map. La chaîne SQL de récupération des données devient alors :

DATA « the_geom from trajets WHERE user_id = %user_id% »

C’est tout simple donc. En intégrant entre pourcentages le même paramètre que celui envoyé dans la requête, MapServer lui substitue la valeur associée, et le contenu renvoyé est ainsi filtré. On peut aussi ajouter des expressions régulières pour valider les valeurs envoyées et éviter une bonne grosse SQL injection.

Tout cela est connu et très pratique. Ca tord un peu le coup à l’aspect normalisé quand c’est utilisé en WMS, mais les normes ça sert aussi à être dépassé. Néanmoins, il reste un obstacle à la mise en cache des résultats. TileCache par exemple, qui joue un rôle de proxy, ne fait suivre au serveur WMS que les attributs de la norme WMS, et génère alors une erreur car %user_id% sans rien y subsitituer n’est pas utilisable en SQL. C’est pourtant pratique de mettre aussi ce type de résultat en cache.

Mais il y a une solution ! L’Alaska Ocean Observation System publie un patch qui permet de faire suivre au travers de TileCache n’importe quel attribut complémentaire pour peu qu’il soit déclaré dans le tilecache.cfg (fichier de configuration du cache). Ils l’ont fait pour faire du WMS-T (WMS temporel, enrichi d’une variable temporelle pour récupérer des observations par exemple), et étendu à tout attribut complémentaire, ce qui mérite d’être salué.

Une des complications impliquée par ce genre de techique est la multiplication des arborescence, puisqu’un cache spécifique sera créé pour chaque valeur du paramètre. Avec des milliers d’utilisateurs dans mon exemple, ça peut rapidement poser problème. Mais pourquoi alors ne pas utiliser un cache mémoire (Tilecache avec MemCache), d’une taille pré-définie ? Avec quelques giga-octets, on pourra y stocker un bon nombre de tuiles, sans jamais surcharger le système. Les plus récemment créées remplaceront les plus anciennes quand le cache sera plein. Cette méthode s’adapte aussi assez bien au temps (presque) réel, puisqu’on peut paramétrer le durée de vie des données stockées par MemCache. Pour un suivi de conditions de circulation (bouchons…), on peut ainsi quand-même profiter d’un cache qui dure le temps de la validité de la donnée. Mais même 10 minutes, si de nombreux utilisateurs se connectent, c’est un considérable allégement de la charge système.

Petit résumé :

Dans OpenLayers :

layer = new OpenLayers.Layer.WMS("Couche dynamique en cache",
"http://serveur.com/tilecache/",
{layers: 'layer_test',format:'PNG',user_id:myUserId},
{isBaseLayer:true,visibility:true});

on a donc surchargé la définition de la couche avec un paramètre user_id qui prend la valeur de la variable javascript myUserId.

Dans Tilecache.cfg :

on ajoute à la définition du layer WMS : extra_params=user_id

Dans le MapFile :

On intègre le paramètre à la chaîne DATA (ou FILTER, ou EXPRESSION, ou CONNECTION selon les besoins) : DATA « the_geom FROM trajets WHERE user_id = %user_id% »

on ajoute une ligne dans le bloc METADATA de la couche pour valider le user_id:

‘user_id_validation_string’ ‘^[0-9]{1,2}$’ qui impose un entier fait de deux chiffres au maximum.

Des tuiles en PHP

Dimanche 11 janvier 2009

Un nouvel outil OpenSource est disponible pour générer un tuilage d’une ressource WMS. Après TileCache, en Python, et GeoWebCache, en Java, voici PHPGeoTiles, pour les adeptes du PHP.

L’originalité, outre le fait qu’il soit écrit en PHP, vient de sa capacité à stocker le tuilage dans Google App Engine, ce qui rendra vos tuiles beaucoup plus disponibles que sur votre propre serveur puisqu’elles bénéficieront de l’infrastructure Google.

via James Fee GIS Blog

Mieux comprendre les tuilages

Mercredi 10 décembre 2008

Voir c’est comprendre, ou du moins mieux comprendre. Cette page réalisée par Klokan Pietr Pridal permet de bien visualiser les grilles de tuilage utilisées en Spherical Mercator, que ce soit en TMS, Google ou QuadTree de Microsoft VirtualEarth.

Chaque pyramide découpe le monde Spherical Mercator selon la même grille, seule change la manière de nommer les tuiles. On remarquera donc l’inversion de l’axe des Y entre le système Google et le TMS (il faut bien faire travailler les développeurs), et le fait que seul le système quadtree puisse s’affranchir de l’information « niveau de zoom » puisqu’il l’intègre naturellement : c’est le nombre de chiffres du numéro de la dalle.

Quelques tuiles pour l’hiver

Lundi 18 août 2008

L’intérêt de tuiler un jeu de données raster, c’est-à-dire de préparer des imagettes multi-échelles qui seront exploitées nativement dans une application de webmapping n’est plus à démontrer. Dans le cadre du Google Summer of Code 2008, Klokan Petr Pridal vient d’ajouter un nouveau module de ce type aux outils GDAL : gdal2tiles.

Son intérêt principal est de pouvoir exploiter directement une image existante (ECW, TIFF, MrSid, JPEG, JPEG2000 et PNG) sans passer par le relai d’un serveur WMS par exemple comme TileCache. Une arborescence est alors créée répondant aux principes du TMS (Tile Mapping Service). Publiée dans un répertoire web, elle est alors directement exploitable par les client TMS tels qu’OpenLayers.

Mais ce n’est pas tout. Klokan a également inclus des options spécifiques à la création de tuiles pour GoogleMaps (en projection sphérique Mercator donc) ou GoogleEarth (en WGS 84). Qui plus est, l’application génère automatiquement, pour peu qu’on lui demande, des fichiers html pour une mise en ligne immédiate. Simple mais efficace, même dans GoogleEarth qui exploite les SuperOverlays déjà disponible avec TileCache !

Mais ce n’est pas tout ! Klokan a également pensé à ceux d’entre nous qui ne sont jamais arrivés à faire une simple conversion ogr2ogr de Shapefile en MapInfo… Il prépare MapTiler, une interface  graphique pilotant gdal2tiles pour générer ses tuiles en faisant clic clic clic ! Si c’est pas gentil ça !

Pour les autres, voici les quelques options glanées dans la documentation :

gdal2tiles.py [-title "Title"] [-publishurl http://yourserver/dir/]
              [-nogooglemaps] [-noopenlayers] [-nokml]
              [-googlemapskey KEY] [-forcekml] [-v]
               input_file [output_dir]
-title : le titre pour les metadata xml, les pages web et le KML
-publishurl : URL de publication du répertoire contenant les tuiles
-nogooglemaps : pas de génération de page GoogleMaps
-noopenlayers : pas de génération de page OpenLayers
-nokml : pas de génération de KML
-googlemapskey : votre clé GM pour l'utilisation de la page html GoogleMaps
-forcekml : forcer la génération du KML
-v : mode verbeux.
input_file : fichier à traiter
output_dir : répertoire de création des tuiles

Il faut bien noter que gdal2tiles.py est un module Python, et que GDAL doit donc avoir été compilé avec l’option –enable-python.

Source : gdal-dev mailing list