Mapserver CGI

Come funziona MapServer: CGI e browse mode

MapServer è uno strumento potente e molto versatile per la realizzazione di webGIS, costituendo un motore efficiente per il rendering di mappe e geodati (mapping engine). Ma bisogna ammetterlo: non è tanto facile da usare! Ecco perchè spesso gli vengono preferite altre soluzioni più “amichevoli”.
Credo allora che spiegare, se pur a grandi linee, i principi del suo funzionamento e le sue modalità d’uso, possa servire per renderlo meno ostico e far comprendere meglio in quali casi e in che modo può convenire adoperarlo.

Diciamo subito che le modalità di funzionamento di MapServer sono due:

  • MapServer CGI: è il suo funzionamento base, consistente in un modulo CGI eseguito tramite un web server (tipicamente Apache) specificandone il modo : MAP mode, BROWSE mode e QUERY mode (per la precisione esistono diversi tipi di QUERY mode);
  • estensione MapScript: è una interfaccia di programmazione che rende possibile l’accesso ai servizi di MapServer (le sue API) tramite diversi linguaggi di programmazione (lato server) come: PHP, Java, Perl, Python, …, etc;

Ognuno dei due funzionamenti ha le sue prerogative ed i suoi vantaggi, ma negli anni (MapServer è nato nel 1996) si è passati ad ud uso più frequente di MapScript, consentendo questo di accedere a funzionalità più complesse e nello stesso tempo di sfruttare le capacità di elaborazione di linguaggi come PHP.

Poichè, anche sintetizzando, l’argomento è vasto, in questo primo articolo (ne seguiranno altri) ci occuperemo solo del funzionamento di MapServer come CGI e più specificatamente in BROWSE mode.

Partiamo col dire che, a prescindere da come si voglia usare, l’ elemento centrale caratterizzante MapServer è il cosiddetto mapfile; quindi per cominciare parliamo di esso.

Il mapfile

L’importanza di questo file di MapServer è indubbia e per spiegare come è fatto e come si costruisce nei dettagli ci vorrebbe molto più spazio! Qui, ovviamente, daremo solo dei cenni, almeno per capire a cosa serve.

Il mapfile è un file di testo strutturato (si può aprire con un normale text-editor) contraddistinto dall’estensione .map, che definisce la configurazione di MapServer per una data applicazione o sessione di lavoro.
Potremmo dire semplicemente che è un file di configurazione, che MapServer legge per sapere: quali sono i dati geografici (layer) che deve gestire, come li deve restituire graficamente (sistema di proiezione, simboli, colori, scala, … etc) e come possono essere interrogati dall’utente (queries).

Per esempio è proprio nel mapfile che si configura MapServer per funzionare come WMS o WFS server (… lo sapete che MapServer può fungere sia da client che da server WMS/WFS, vero ?). Ogni servizio WMS/WFS fornito richiede un suo mapfile e c’è la possibilità di impostarlo sia a livello globale (per tutti i layer della mappa) che a livello di singolo layer.

La sua è una struttura gerarchica costituita da oggetti che va scritta rispettando delle regole di sintassi abbastanza articolate; questo è il motivo per cui scrivere a mano un mapfile è abbastanza difficile, specie quando è composto da molti elementi e con diverse opzioni.
Esistono delle soluzioni e degli editor che aiutano nella compilazione di un mapfile; uno di questi è un plugin di QGIS di cui abbiamo già parlato in questo altro articolo. Altre soluzioni le trovate indicate in questa pagina del progetto MapServer su Github: MapFile editors.

Ma può succedere che un mapfile generato con questi strumenti ausiliari (alcuni sperimentali o incompleti) non sia perfettamente compatibile con la sintassi esatta di MapServer e quindi in fase operativa vengano fuori degli errori o risultati diversi da quelli aspettati.

Considerate anche che, nell’evoluzione delle versioni di MapServer, in alcuni casi sono cambiate anche alcune regole per il mapfile; per cui, mapfile funzionanti su precedenti versioni non vanno più bene per quelle nuove. Sottolineo questa evenienza, perché capita spesso che prendendo dei mapfiles già pronti (nel web ci sono tanti tutorial ed esempi), messi alla prova non funzionino.

Come dicevamo prima, un mapfile è composto da oggetti ognuno caratterizzato da dei parametri (o proprietà) e dalla possibilità di includere altri oggetti; per questo si parla di una struttura gerarchica in cui ogni oggetto assume un certo significato anche a secondo degli oggetti (genitori) che lo contengono.
I valori ammessi per i parametri possono essere di diverso tipo (numeri, stringhe, booleani, … etc) e vanno scritti rispettando le regole sintattiche ed in alcuni casi anche il range o l’insieme dei valori possibili.

Sul sito ufficiale di MapServer, trovata il  mapfile reference  per l’ultima versione rilasciata.

Per citare alcuni dei principali oggetti di un mapfile, ricordiamo:

  • MAP : è l’oggetto principale del mapfile che include tutti gli altri (scritto all’inizio);
  • LAYER : definisce un layer (raster o vettoriale) della mappa, indicando innanzitutto il sorgente (dove si trova) e poi tutte le sue altre caratteristiche: proiezione, stile, etichette, …. etc;
  • CLASS : definisce l’aspetto grafico di un layer, quindi ogni LAYER deve avere al suo interno almeno un oggetto CLASS (se un layer può cambiare aspetto a secondo di certe condizioni, contiene più CLASS diverse);
  • STYLE : definisce la stile da adottare per i simboli rappresentati in un layer (è contenuto dentro l’oggetto CLASS) o più in generale della mappa;
  • LABEL : definisce l’aspetto delle etichette utilizzate per un layer (è contenuto dentro l’oggetto CLASS) oppure per altri oggetti: la mappa, la legenda, il righello della scala, … etc;
  • WEB : definisce vari parametri relativi al funzionamento dell’interfaccia web attraverso cui si invoca MapServer (si capirà meglio il suo utilizzo più avanti).

La seguente figura mostra la posizione gerarchica di alcuni dei principali oggetti e si nota come alcuni (per es. STYLE e LABEL) possano trovarsi in livelli diversi e sotto oggetti diversi.

oggetti mapfile

La regola principale di scrittura, prevede che ogni gruppo di righe che definisce un oggetto inizi col suo stesso nome (per es. LAYER) e termini con la parola END; al suo interno troviamo i suoi parametri con i relativi valori e gli eventuali altri oggetti. La identazione delle righe non è obbligatoria, ma può aiutare nella lettura del codice, perchè evidenzia la posizione degli oggetti diversi, uno dentro l’altro.

Il mapfile è case-insensitive, cioè le parole chiave possono scriversi maiuscolo o minuscolo indifferentemente; ma comunque scriverle in maiuscolo può aiutare per distinguerle dai valori. Anche l’inserimento di righe di commento può migliorare la leggibilità di un mapfile; esse si distinguono perchè vengono precedute dal simbolo “#” .

Tutti i path dei file contenuti al suo interno possono essere assoluti o relativi alla sua posizione nel file-system

Di seguito vediamo come esempio, un semplice  mapfile, che configura una mappa costituita da tre layers: un layer1 vettoriale (poligoni), un layer2 che è una mappa raster e un layer3  anch’esso vettoriale (linee).
Per ognuno di essi, il nome del file di origine è specificato col parametro DATA e la loro posizione dipende dal parametro SHAPEPATH della mappa; questo infatti definisce la directory principale dove sono contenuti i dati (nonostante il nome, non vale solo per gli spapefiles).

MapServer rappresenta i layer di una mappa, nell’ordine in cui sono scritti nel mapfile; quindi il secondo viene sovrapposto al primo, il terzo al secondo e così via. Questo è importante saperlo perchè a secondo della trasparenza o meno di un layer, cambia il risultato della mappa complessiva; normalmente i layer opachi (basemaps) vanno scritti prima degli altri (overlays).

Oltre ai tre layers, per l’oggetto MAP sono stati definiti i seguenti oggetti:

  • WEB contiene dei parametri per il funzionamento dell’interfaccia web;
  • PROJECTION definisce il sistema di riferimento (col relativo codice EPSG) usato per la mappa;
  • LEGEND definisce il riquadro per la legenda;
  • REFERENCE definisce il riquadro della reference-map (intera estensione della mappa in piccolo con l’indicazione della posizione della porzione di mappa corrente);
  • SCALEBAR definisce la barra della scala.

Ma ci chiediamo: nella pratica come si adopera un mapfile? Se si realizza un’applicazione webGIS o anche un semplice visualizzatore web di mappe e dati geografici, che ruolo ha?
In minima parte dipende anche da come viene usato MapServer: come CGI o tramite MapScript; in ogni caso, come già detto e come mostra anche il seguente schema (tratto dal sito ufficiale), il ruolo del mapfile è centrale in ambedue i casi.

architettura MapServer

MapServer CGI

Nella sua forma base MapServer è un programma CGI che viene eseguito come modulo di un web server (tipicamente Apache) ogni volta che viene interpellato; per capirlo meglio, credo che la definizione di CGI (Common Gateway Interface) presente in Wikipedia possa essere chiarificatrice:
… CGI è una tecnologia standard usata dai web server per interfacciarsi con applicazioni esterne generando contenuti web dinamici. Ogni volta che un client richiede al web server un URL corrispondente ad un documento in HTML gli viene restituito un documento statico; se l’URL corrisponde invece ad un programma CGI, il server lo esegue in tempo reale, generando dinamicamente informazioni per l’utente.
… Il file CGI è un semplice programma già compilato e la risposta viene acquisita attraverso standard output. L’acquisizione dei parametri può avvenire attraverso variabili d’ambiente, passaggio di parametri sulla riga di comando o lo standard input a seconda della mole di dati e delle scelte del programmatore.

In pratica quando un utente web fa una richiesta destinata a MapServer CGI, questa viene trasmessa tramite protocollo HTTP al web server, il quale però non ha la capacità di interpretarla e allora, tramite il relativo modulo CGI, la passa a MapServer. Questo elabora la richiesta e poi, sempre tramite CGI, passa i risultati in una forma capibile al web server che li trasmette in HTML al browser dell’utente che così può visualizzarli.

Se MapServer CGI è correttamente installato nel vostro sistema (in questo mio articolo si parla di come di installa su Ubuntu) scrivendo nel browser l’URL:

  •  http:// localhost/cgi-bin/mapserv se siete su localhost;
  •  http:// www.mio_server.com/cgi-bin/mapserv, se al web server corrisponde un dominio “www.mio_server.com”;

otterrete una risposta come questa:

risposta Mapserver CGI

vuol dire che MapServer CGI è pronto per rispondere alla richieste degli utenti.

Per esempio se abbiamo un mapfile  di nome mia_mappa.map dentro la cartella /var/www/html/ (nel caso di sistema Linux) possiamo fare una richiesta come questa:

e otterremo come risposta una immagine statica della mappa con tutti i suoi layer, così come è stata configurata nel mapfile. Attenzione che la cartella in cui viene messo il mapfile, deve essere accessibile al web server (almeno in lettura).

mappa statica

Questo modo di usare MapServer CGI (si chiama MAP mode) è ovviamente troppo elementare: si ottengono solo delle mappe statiche senza nessuna possibilità di interazioni con l’utente, neanche quelle basiche come per esempio lo spostamento (panning) e l’ingrandimento/riduzione (zooming) della mappa.

Per poter visualizzare una mappa ed interagire con essa, si utilizza invece il cosiddetto BROWSE mode, che come dice il termine stesso (browse), permette all’utente di effettuare delle azioni e delle richieste. La maniera più semplice per farlo, consiste nell’utilizzo di files HTML, detti template files, che realizzano un’interfaccia web bidirezionale tra l’utente e MapServer CGI:

  • in uscita: per inviare comandi o richieste a MapServer;
  • in ingresso: per ricevere le risposte (immagini e dati) da MapServer

in altre parole si può dire che con i template files si costruiscono degli elementari web client.

Oltre che dal template file, MapServer CGI riceve indicazioni su come creare le mappe o rispondere a interrogazioni sui dati anche dal mapfile. In esso infatti ci sono quelle istruzioni che non sono affidate all’utente o sulle quali egli non interviene direttamente  se non attivando/disattivando o cambiando il codice del mapfile. Esiste infatti la possibilità di modificare parti di codice del mapfile attraverso l’utilizzo di URL o moduli HTML implementati ad hoc nel template file (Run-time substitution).

La seguente figura schematizza il funzionamento di MapServer CGI in BROWSE mode:

  1. l’utente visualizza il template file (pagina HTML) sul suo browser;
  2. dal template file fa qualche azione che implica una richiesta a MapServer CGI;
  3. MapServer CGI elabora la richiesta pervenuta dal template file anche tenendo conto delle indicazioni presenti nel mapfile (per esempio dove sono i dati geografici da elaborare/visualizzare);
  4. MapServer CGI produce i risultati (mappa, dati, legenda, barra della scala, … etc ) e tramite il template file li restituisce sul browser dell’utente.

Mapserver browse mode

MapServer CGI utilizza i parametri ricevuti dal template file e quelli letti nel mapfile per elaborare una serie di immagini temporanee: la mappa e altri oggetti complementari (legenda, carta di riferimento, barra di scala, … etc), o per creare un file con i risultati delle query. Tutto questo viene salvato in una cartella di file temporanei (che il web server deve poter accedere) e poi visualizzato dentro il template file; come si chiama e dove si trova questa cartella, è indicato dentro il mapfile, con il parametro IMAGEPATH dell’oggetto WEB.

MapServer CGI sa qual’è il template file da leggere (in un sistema server ci possono essere tanti template files per applicazioni differenti), perché esso è indicato nel mapfile dentro l’oggetto WEB. Questo prevede infatti, un parametro template in cui indicare il path o l’URL del template file da usare come interfaccia web. Oppure il parametro “template” può essere definito e trasmesso a MapServer CGI in fase di inizializzazione (vedremo come più avanti).

Il template file

Quello che vede l’utente nel suo browser è quindi un template file; si tratta di un normale file HTML che serve a definire la struttura e l’aspetto dell’interfaccia utente per MapServer CGI. E’ necessario (questo a partire dalla versione 5.4) che la prima riga del codice del template file sia la seguente:

  • <!– MapServer Template –> se è scritto in HTML
  • // MapServer Template  se è scritto in JavaScript

Per esempio un template definisce dove mettere: il titolo della mappa, l’immagine della mappa, la barra della scala, i pulsanti dello zoom, … etc. Le sue funzionalità possono essere migliorate aggiungendo anche codice scripting client-side; normalmente JavaScript (JS) o Java. Oltre che per visualizzare delle mappe e i vari elementi per gestirle, i template servono anche per la visualizzazione dei risultati delle query spaziali. Ma come vederemo tra poco, quello che effettivamente differenzia un template file da una classica pagina HTML sono le variabili CGI.

MapServer CGI è stateless (cioè gestisce ogni richiesta senza tener conto di quella precedente) e va in esecuzione quando viene invocato da una azione/richiesta dell’utente, realizzando ogni volta una nuova sessione. In questo modo le azioni dell’utente producono una sequenza di sessioni (immagini e risultati) che fanno cambiare aspetto alla pagina web realizzata col template file, rendendola di fatto una pagina dinamica.

Ma tecnicamente come avviene questa interazione tra un template file e MapServer CGI?

  • per l’invio di richieste (parametri)  si usa il tag <FORM> del linguaggio HTML o un URL;
  • per ricevere le risposte si usano le variabili del template file.

Il  tag <FORM>, come è noto (almeno per chi conosce l’HTML), è un costrutto per inviare dati dal browser dell’utente al web server. Al suo interno vengono definiti dei tag, i più usati sono <INPUT>  e <SELECT>,  che definiscono delle variabili di ingresso a cui assegnare dei valori o tramite standard input (tastiera, mouse) oppure dentro il codice HTML stesso, senza intervento dell’utente (sono le variabili di tipo hidden).

Il tag <FORM> prevede che l’invio dei parametri al web server possa avvenire con due diversi metodi: GET e POST. Senza scendere nei dettagli (qui non ci interessa), la differenza fondamentale tra i due è che il primo (GET) passa i dati come parametri all’interno dell’indirizzo della pagina web che li riceverà, mentre il secondo (POST) mantiene intatto l’indirizzo della pagina di ricezione e usa un altro canale.
Nel nostro caso la pagina ricevente è in realtà il CGI di MapServer; infatti nella definizione del FORM, viene indicato il parametro action=”/cgi-bin/mapserv”. Inoltre, per dei motivi che non vi sto qui a spiegare, viene sempre preferito il metodo GET.

I parametri che possono essere usati per interloquire con MapServer CGI sono quelli elencati qui: MapServer CGI controls. Si adoperano specificando nell’attributo name dei tag <INPUT> e <SELECT> il loro nome (BUFFER, LAYER, MAP, MAPEXT, ZOOM, ZOOMDIR, … etc), maiuscolo o minuscolo non ha importanza.

Le variabili CGI

Le variabili CGI o variabili di sostituzione o ancora template reference , sono caratteri/stringhe speciali presenti in un template file che vengono racchiuse tra […]. Ogni volta che MapServer CGI viene invocato, scorre il template file e rimpiazza queste variabili con i loro valori correnti che derivano dalla sua esecuzione; questo modifica il contenuto del template file e quindi la sua visualizzazione nel browser dell’utente.

Ogni variabile è destinata per un rilevare un determinato aspetto dell’esecuzione di MapServer CGI. Per esempio la variabile [img] serve per contenere l’immagine della mappa “renderizzata” (o meglio il nome del suo file); ogni volta che la mappa cambia aspetto, perché l’utente ha effettuato una qualche azione, MapServer CGI genera una nuova immagine, la salva nella cartella dei file temporanei e poi al posto di [img] sostituisce il nome del suo file.

Di seguito vediamo un esempio di template file (una parte), in cui sono evidenziate le variabili di sostituzione usate:

variabili CGI

Da notare che le variabili possono essere usate anche per definire il valore di alcuni parametri da inviare a MapServer (cioè degli input di un FORM), anzi di norma è così. Questa cosa dipende dal fatto che ogni nuova richiesta inviata al server dipende anche dallo stato attuale dell’applicazione, quindi dal valore attuale di determinate variabili.

Le  variabili previste per MapServer le trovate definite in questa pagina: MapServer templating e sono raggruppate per destinazione d’uso nelle seguenti categorie:

  • general
  • file reference
  • image geometry
  • map geometry
  • layer
  • zoom
  • query (disponibili per i query template, cioè quelli costruiti per presentare i risultati di una interrogazione).

Oltre a queste, l’utente può anche definire delle sue variabili (variabili utente) sempre indicando il loro nome tra […]; sono comode per mantenere dei parametri che vengono passati di sessione in sessione in un template file, al susseguirsi delle azioni/richieste dell’utente. MapServer CGI le tratta come le altre variabili predefinite, cioè gli sostituisce il valore corrente ogni volta che va in esecuzione. L’unica differenza è che il loro valore viene assegnato inizialmente dall’utente e ovviamente per nominarle, non si possono adoperare le parole riservate predefinite.
Per esempio si può definire una variabile [root] che contenga il path della home-directory con i file HTML dell’applicazione.

Attenzione a non fare confusione! Infatti anche i parametri CGI per controllare MapServer che abbiamo visto prima (MapServer CGI controls), vengono chiamate variabili CGI; ma sono una cosa diversa da queste indicate tra […] e che se vogliamo, possiamo indicare più propriamente come variabili di sostituzione (template substitution strings).

Il file di inizializzazione

Visto il meccanismo con cui MapServer CGI aggiorna le variabili presenti in un template file, si capische che la prima volta questo deve essere inizializzato, cioè si devono inviare a MapServer CGI i dati iniziali per ottenere la prima “vista” dell’applicazione.
Delle informazioni tipiche di avvio sono per esempio: il nome del mapfile da usare, l’estensione e il livello di zoom iniziali della mappa, i layer da visualizzare all’inizio, .. etc.
Sempre in fase di inizializzazione, vanno definiti i valori di partenza delle variabili definite dall’utente.

Questa inizializzazione può essere fatta in tre modi:

  • tramite un altro file HTML detto file di inizializzazione che si preoccupa dell’invio di questi dati ;
  • scrivendo il codice di inizializzazione dentro lo stesso template file;
  • specificando i parametri iniziali necessari all’interno di un URL.

Nei primi due modi,  il codice di inizializzazione è realizzato sempre con un <FORM> in cui come variabili di <INPUT> vengono specificati appunto i parametri iniziali per MapServer CGI. Definendo uno stato iniziale, sono tutti valori costanti (non ci sono variabili); questo implica che volendo, come metodo di trasmissione si potrebbe pure scegliere il POST.

Un’altra caratteristica del <FORM> di inizializzazione è che tutte le variabili di <INPUT> sono di tipo hidden, ovvero il loro valore è scritto nel codice e non richiede un input diretto dell’utente.

Quando il codice di inizializzazione viene scritto in un file a parte (file di inizializzazione), questo viene aperto come primo file dell’applicazione e poi da esso si passa al template file, definito nel parametro template del mapfile.

Il codice di inizializzazione può pure essere incluso nello stesso template file. In questo caso,  dentro lo stesso FORM avremo sia i parametri iniziali che quelli per le richieste successive. Si adotterà qualche stratagemma per inviare la prima richiesta di inizializzazione; per esempio, potrebbe trattarsi di un bottone “inizializza” che l’utente schiaccia solo la prima volta.

Infine i parametri di inizializzazione possono essere inviati a MapServer CGI con un URL in cui vengono elencate le coppie parametro-valore, una dopo l’altra, separate da “&”; per fare un esempio i parametri del precedente form di inizializzazione verrebbero trasmessi così:

Per comprendere ancora meglio tutto ciò di cui abbiamo parlato (purtroppo sinteticamente), vi consiglio (specie se siete alle prime armi) di guardare il tutorial che MapServer mette a disposizione in questa pagina: MapServer 5.x tutorial e soprattutto testare gli esempi pratici proposti. Tra l’altro c’è anche la possibilità di scaricarlo ed installarlo su una propria macchina con MapServer, così che potete fare anche delle modifiche (ai template files e/o ai mapfiles) e vedere cosa succede. In particolare la “sezione 2” contiene esempi sul funzionamento dei template files; in fondo alla pagina di questa sezione, trovate i link a 5 esempi:

MapServer CGI esempi

Se guardate bene come è fatto ogni link, non sono dei semplici richiami ad altre pagine web ma, si tratta di URL di inizializzazione, in quanto con essi vengono trasmessi a MapServer tutti i parametri iniziali (innanzitutto il mapfile) che servono per avviare il dato esempio.

Ovviamente come dice il titolo, si tratta di esempi scritti per la versione di MapServer 5, quindi attenzione che se li provate con una versione più recente di MapServer (oggi siamo alla 7), qualche cosa potrebbe non funzionare correttamente e quindi dovrete fare degli aggiustamenti.

Interfacce web per MapServer CGI

Nonostante il non indifferente numero di controlli/parametri che ha MapServer CGI e quindi le funzionalità disponibili per l’utente, resta comunque il grosso limite che con i template files non si possono realizzare delle interfacce efficienti e complesse, quali oggi siamo abituati ad avere; anche i tutorial che  vi ho segnalato prima, ne sono una prova.

I template files possono essere migliorati con opportuno codice JavaScript ( o anche Java) che implementi delle funzionalità più avanzate e soprattutto una maggiore fluidità di aggiornamento della mappe. Se siamo pratici di JS, ce lo possiamo scrivere direttamente, oppure si possono richiamare moduli e librerie già pronti. In ogni caso è una soluzione impegnativa e che richiede molto tempo, specie se l’obiettivo è realizzare un’applicazione di web mapping evoluta.

Un pò di anni fa, era stato sviluppato un pacchetto di nome MapLab composto da tools che aiutavano lo sviluppatore a realizzare applicativi per MapServer CGI senza editare tutto a mano: MapEdit per scrivere il mapfile e GMapFactory per progettare l’interfaccia web (HTML+Java). MapLab ancora è disponibile (www.maptools.org/maplab/) ma è ormai obsoleto, infatti la sua ultima versione, la 2.2.1, risale al lontano 2005.

Oggi abbiamo delle alternative più moderne per la gestione di geodati in generale e alcune si possono usare anche con MapServer CGI; si tratta di librerie già pronte (quasi tutte in JS) oppure ancora meglio di framework, cioè raccolte di strutture e funzionalità software già codificate che il programmatore può usare, assemblandole, per realizzare la sua web application.

Tra le librerie JS, innazitutto non poteva mancare OpenLayers. Nella versione 2 c’è proprio una classe OpenLayers.Layer.MapServer  per ottenere dei layer da una istanza di MapServer CGI; essa consente di invocare tramite URL (al solito del tipo http://mio_server.com/cgi-bin/mapserv) MapServer CGI e passargli tutti i parametri necessari per ottenere la restituzione del layer nella maniera desiderata.

In OpenLayers 3 non è stata prevista alcuna API specifica per MapServer (almeno fino ad oggi), ma ci si può connettere usando la classe generica ol.source.XYZ; con questa tramite il solito URL possiamo invocare MapServer CGI e passargli i parametri che ci servono. Un’altra possibilità consiste nel configurare MapServer come servizio WMS (abbiamo già visto che questa configurazione si effettua nel mapfile) e poi ci si connette con OL3 nel modo standard per gestire questo servizio (client WMS).

Sono diversi i framework open source che negli anni sono stati sviluppati per realizzare applicazioni di web mapping  aventi MapServer (ma non solo) come motore GIS ; la maggior parte di questi possono essere usati solo se è installata la sua estensione MapScript, ma altri (basati su JavaScript) funzionano anche con MapServer CGI.

Uno dei più noti è ka-Map (ka-map.maptools.org), un applicativo in AJAX che presenta un’interfaccia web molto intuitiva per usare MapServer CGI, senza preoccuparsi di scrivere dei template files. Esistono delle realizzazioni anche abbastanza recenti basate su ka-Map, ma si tratta comunque di un progetto ormai vecchio e non più aggiornato (l’ultima release è del 2006).

Un framework più attuale ed aggiornato è invece GeoMOOSE (www.geomoose.org). Realizzato in PHP ma anche con JS ed OpenLayers, è un web client progettato proprio per usare  MapServer, sia con MapScript che come CGI. Offre una soluzione ricchissima di  funzioni per realizzare  webGIS accattivanti e moderni; il progetto fa parte del gruppo OSGeo ed è in piena attività: l’ultima release (la 2.9.0) è stata rilasciata a maggio 2016.

Un’altro importante framework del gruppo OSGeo è MapFish (www.mapfish.org); è basato su pylons, un web framework realizzato in python, che però viene esteso con altre funzionalità tipiche per dati geospaziali. Infatti MapFish comprende anche un toolbox JavaScript composto da OpenLayers, ExtJS (per la GUI) e GeoExt; per cui praticamente la parte relativa al mapping può essere gestita esattamente come si fa in OL. 

Per chi sa già usare OL, il passaggio a MapFish è quindi semplice; bisogna solo prendere dimestichezza con il modo in cui ExtJS gestisce il layout e gli eventi dell’interfaccia utente e con gli utili widget propri di MapFish (es.: toolbar, layer-tree, print, db-searching, … etc). Quindi anche per usare MapServer CGI, ci si comporta come per OL, preferendo in genere la soluzione tramite collegamento WMS.

Per concludere …

MapServer come CGI è praticamente solo un “motore” per riprodurre su delle pagine web: mappe, dati (attributi di layer vettoriali) ed eseguire delle interrogazioni spaziali non troppo complesse, oppure per fungere da server OGC (WMS, WFS e WCS). Non si può pensare di realizzare delle vere funzionalità GIS, soltanto con esso e dei template files. Ma d’altra parte MapServer è stato progettato proprio per questo scopo!

Il grosso passo avanti, come accennato all’inizio di questo articolo, ce lo permette l’estensione MapScript e l’accesso alle sue API  da linguaggi quali PHP, Perl, Python, … etc. In questo modo, oltre ad avere tutte le funzionalità di Mapserver CGI, se ne possono realizzare anche di più complesse, quali: interazioni evolute con la mappa (selezioni, editing, interrogazioni, … etc), analisi spaziali, funzioni di geoprocessing e di reporting, tipiche di un vero sistema GIS.

condividi: