Archivio
Test automation su web gis application “OpenLayers based” usando Selenium Web Driver
Per ragioni lavorative mi sono occupato di valutare l’utilizzo della suite Selenium HQ per il test automation di web application.
Tale suite risulta essere uno dei principali prodotti open source di test automation per web application: sostanzialmente è caratterizzato da due tool, Selenium IDE e Selenium Web Driver (ve ne sono poi altri due, Selenium Grid e Selenium Remote Control che non ho analizzato).
Selenium IDE è un plugin per Firefox (non esiste omologo per altri browser), che permette di catturare una sessione utente di una web application (comprese le azioni di imputazione di dati ….), produrre automaticamente uno script che può poi essere rieseguito come tale o modificato.
Il tool è adatto per test semplici (sostanzialmente adatto per l’entry level …), non richiede alcuna conoscenza tecnica pregressa (sebbene un profilo tecnico, tipo programmatore, probabilmente riesce ad ottenere il meglio dallo strumento ….), ed è molto facile da utilizzare: ha tuttavia dei limiti che, anche con le personalizzazioni degli script ottenuti automaticamente, difficilmente possono essere superati.
La maggior parte della comunità che utilizza la suite Selenium utilizza per i propri scopi Selenium Web Driver.
Selenium Web Driver permette di creare delle vere e proprie suite di test programmando i test cases nei principali linguaggi di programmazione (Java, Ruby, Python, ecc …): nel mio caso ho utilizzato Java ma questa non è la scelta esclusiva anche se è quella per cui forse si trovano maggiori esempi, documentazione e supporto.
Sostanzialmente Web Driver “emula” una sessione browser ma lo fà server-side.
La sua installazione (è necessario usare Eclipse …), è molto semplice e ben documentata (nel senso adatta anche a chi non ha grosse conoscenza tecniche, si tratta di un tutorial veramente descritto “passo – passo” ….), sul sito di Selenium o in vari altri blog.
A differenza di Selenium IDE è quindi rivolto ad una utenza decisamente più tecnica, diciamo figure professionali con profili da programmatore (e la cosa si evidenzia andando a vedere il supporto che si ottiene on-line sui vari StackExchange, StackOverflow, ecc …, nel senso che chi risponde sono tutte figure di questo genere, lo si intende dal livello di risposte fornite).
Fatta questa esperienza professionale ho deciso di provare a vedere come il tool si comportava con web gis application che sono tipicamente caratterizzate da un abbondante uso di librerie javascript, anche “verticali” quali OpenLayers o Leaflet, e un livello di interattività (intendo quello sulla mappa ….), decisamente superiore ad una tipica web application gestionale.
Ho quindi provato a vedere cosa succedeva ad utilizzare Web Driver inizialmente con alcuni degli esempi consultabili sul sito di OpenLayers 2.13, ed infine con una web gis application “vera” Java based ed utilizzante OpenLayers ed ExtJS (non ho provato per ragioni di tempo con Leaflet ma credo che, rispetto alle conclusioni che se ne possono trarre, la cosa sia piuttosto invariante).
I .jar che vi potete scaricare dovrebbero essere eseguibili direttamente dando il seguente comando:
java -jar <nome_esempio>.jar
e richiedono come minimo la jdk 1.6.
Vi condivido comunque il codice sorgente in modo che, chi interessato, una volta installato e configurato Eclipse con le diverse librerie che servono per Web Driver (per l’installazione e configurazione vi rimando alla documentazione ufficiale …).
In merito al codice sorgente solo una nota: il codice è puramente a scopo didattico e pensato per poter essere compilato ed eseguito nel maggior numero di situazioni, non và preso come codice di “produzione”, per cui i “puristi” o i programmatori veri (cosa che io oramai non sono più ….), non me ne vogliano per le diverse System.out che troveranno nel codice, sò da me che avrei dovuto usare, come deve essere fatto correttamente, Log4J e compilare di conseguenza, ma lascio il tutto a coloro che vorranno poi scrivere dei test cases veri.
Altra cosa è che i test case NON analizzano come trattare eventuali situazioni di errore: il loro focus è provare se si riesce a simulare una sessione utente che comprenda le principali interazioni con la mappa. Trattandosi di test case realizzati in modalità “programmatica” la gestione dell’errore viene lasciata alla modalità organizzativa ritenuta più efficace dall’organizzazione: raccogliere i dati su un database, scatenare eventi, inviare messaggi, tracciare su file di log, ecc … Ovviamente tutto questo era, al momento, out-of-scope di queste prove.
Vediamo allora il primo test case sull’esempio base di OpenLayers effettuando uno zoom in interattivo sulla mappa
Il codice sorgente che implementa questo test è il seguente:
package myTests;
import java.util.concurrent.TimeUnit;
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.firefox.FirefoxProfile;
import org.openqa.selenium.firefox.internal.ProfilesIni;
import org.openqa.selenium.interactions.Actions;
public class interactiveZoomInOpenLayerstest_01 {
private static WebDriver driver = null;
public static void main(String[] args) throws InterruptedException {
//Create a new profile and load my Firefox default profile
System.out.println("Creo un nuovo profilo e vi carico il profilo di default di Firefox ...");
Thread.sleep(3000L);
ProfilesIni profile = new ProfilesIni();
FirefoxProfile ffProfile = profile.getProfile("default");
// Create a new instance of the Firefox driver using my new Firefox profile
System.out.println("Creo una nuova sessione del browser Firefox ...");
Thread.sleep(3000L);
driver = new FirefoxDriver(ffProfile);
//Put a Implicit wait, this means that any search for elements on the page could take the time the implicit wait is set for before throwing exception
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
// It is always advisable to Maximize the window before performing DragNDrop action
System.out.println("Massimizzo la finestra del browser ...");
Thread.sleep(3000L);
driver.manage().window().maximize();
//Launch the OpenLayers 2.x sample
System.out.println("Mi collego all'esempio di OpenLayers 2.x ...");
Thread.sleep(3000L);
driver.get("http://dev.openlayers.org/releases/OpenLayers-2.13.1/examples/example.html");
// Find the viewport inside in witch there is the map
System.out.println("Individuo il viewport al cui interno c'è la mappa ...");
Thread.sleep(3000L);
WebElement el = driver.findElement(By.id("OpenLayers_Map_2_OpenLayers_ViewPort"));
// Create a new Action instance
System.out.println("Creo un oggetto di tipo \"Action\" ...");
Actions act = new Actions(driver);
// Moves to 2nd location
System.out.println("Moves to 1st location: 200, 50 ...");
Thread.sleep(3000L);
// Draw rectangle and execute zoom in
System.out.println("Moves to 1st location: 300, 150 ...");
act.moveToElement(el,200,50).click().keyDown(Keys.SHIFT).clickAndHold().moveToElement(el, 300, 150).click().release().keyUp(Keys.SHIFT).build().perform();
// Print TEST = OK!!
System.out.println("TEST = OK !!");
//driver.quit();
}
}
Il codice sorgente è liberamente scaricabile.
E’ possibile anche scaricare lo zip dell’eseguibile Java: una volta decompresso posizionarsi in
InterActiveZoomInTest\InterActiveZoomIn\jar
e poi riprodurlo in locale con il seguente comando
java -jar InterActiveZoomIn.jar
Vediamo ora il secondo test case sull’esempio del calcolo della misura di un’area disegnata interattivamente di OpenLayers
Per brevità non si riporta il codice sorgente che comunque liberamente scaricabile.
E’ possibile anche scaricare lo zip dell’eseguibile Java: una volta decompresso posizionarsi in
MeasureAreaOpenTest\MeasureAreaOpenLayers\jar
e poi riprodurlo in locale con il seguente comando
java -jar MeasureAreaOpenLayers.jar
Vediamo ora il terzo test case sull’esempio di OpenLayers dell’interrogazione interattiva di un marker presente sulla mappa
Per brevità non si riporta il codice sorgente che comunque liberamente scaricabile.
E’ possibile anche scaricare lo zip dell’eseguibile Java: una volta decompresso posizionarsi in
IdentifyOpenLayersTest\IdentifyOpenLayers\jar
e poi riprodurlo in locale con il seguente comando
java -jar IdentifyOpenLayers.jar
Vediamo ora il quarto test case sull’esempio di OpenLayers dell’interrogazione interattiva di geometrie di un servizio WMS presente sulla mappa
Per brevità non si riporta il codice sorgente che comunque liberamente scaricabile.
E’ possibile anche scaricare lo zip dell’eseguibile Java: una volta decompresso posizionarsi in
GetFeatureInfoWMSTest\GetFeatureInfoWMSTest\jar
e poi riprodurlo in locale con il seguente comando
java -jar GetFeatureInfoWMSTest.jar
Vediamo ora il quinto test case sull’esempio di OpenLayers dell’editing interattivo su mappa
Per brevità non si riporta il codice sorgente che comunque liberamente scaricabile.
E’ possibile anche scaricare lo zip dell’eseguibile Java: una volta decompresso posizionarsi in
EditingOpenLayersTest\EditingOpenLayers\jar
e poi riprodurlo in locale con il seguente comando
java -jar EditingOpenLayers.jar
Ma il tutto è applicabile anche a progetti reali? La risposta è sì: ho provato a costruire una navigazione interattiva su un progetto di web mapping reale di Regione Piemonte ad accesso libero realizzato con MapStore (prodotto open source realizzato partendo da GeoExplorer e quindi basato su ExtJS e OpenLayers).
Per brevità non si riporta il codice sorgente che comunque liberamente scaricabile.
E’ possibile anche scaricare lo zip dell’eseguibile Java: una volta decompresso posizionarsi in
AeraTest\AeraProject\jar
e poi riprodurlo in locale con il seguente comando
java -jar AeraProject.jar
Occorre precisare che la realizzazione di test suite richiede l’impegno di risorse con un profilo tecnico (programmatori) medio-alto, e non è banale per cui anche i tempi di realizzazione non sono bassi: non è quindi ammortizzabile, in termini di costi, per progetti “piccoli”, mentre per progetti medio – grandi, in particolare se critici o sensibili per aspetti diversi, sicuramente, una volta redatti ed automatizzati i test, si ha la possibilità di eseguirli automaticamente in tempi molto rapidi e tutte le volte he lo si ritiene necessario.
Essendo in questo caso le suite di test “codice”, le si possono (anzi le si devono ….), trattare come tali e quindi possono (devono), essere mantenuti su repository da cui, con tools di software automation, agganciare a processi di building automatici che permettano di eseguire i test automaticamente ad ogni rilascio significativo del codice di business dell’applicazione.
Non occorre però scordare due aspetti fondamentale che esulano dall’automazione: il codice delle suite di test deve essere manutenuto allo stesso modo del codice di business applicativo e, altro aspetto fondamentale, anche la base dati su cui si eseguono i test deve essere mantenuta (o replicata), coerente.
Concludendo quindi si può dire che per l’automazione di test di web mapping application si possono usare senza problemi i medesimi tools che si utilizzano per le web application gestionale e che quindi, in questo caso …. “spatial is not special” !!!
OpenGeo investe nella comunità QGIS
Sul blog di OpenGeo oggi è apparso un post che annuncia l’interesse di OpenGeo nell’investire in QGIS desktop.
La notizia ha una certa rilevanza visto che OpenGeo sinora si è storicamente concentrata sulle componenti server enterprise: la sua OpenGeo Suite che si basa infatti sulla OpenGeo Architecture costituita da PostGIS, GeoServer, GeoWebCache, OpenLayers e GeoExt.
In questo scenario mancava una soluzione GIS Desktop matura che permettesse di completare la suite e la scelta sembra essere caduta su QGIS che sicuramente è il tool GIS Desktop open source più ampiamente diffuso ed utilizzato, con una nutrita e quanto mai vivace comunità e che si appresta a rilasciare la release 2.0.
Questa notizia potrebbe rivelarsi una svolta importante nel panorama delle soluzioni GIS open source visto che nell’offerta di OpenGeo si va a completare un tassello sinora non integrato.
Le potenzialità sono molte e tutte decisamente interessanti:
- integrazione di QGIS nella OpenGeoSuite diventando uno strumento non solo per fare gis desktop ma anche un modo per fare configurazione della suite stessa: gli utenti della suite potranno quindi prossimamente creare, analizzare, pubblicare e consumare dati e servizi geospaziali
- integrazione di QGIS con GeoGit, la soluzione per il versionamento dell’informazione spaziale su sui OpenGeo sta lavorando. Gli utenti desktop saranno in grado di lavorare su dati geospaziali in ambienti distribuiti o parzialmente disconnessi. Il client GeoGit in QGIS permetterà non solo agli utenti di gestire i loro repository e quindi le proprie versioni, ma anche di avere a disposizione l’intero contesto di QGIS, rendendo GeoGit un altro data source dentro QGIS, esattamente come ogni altro database o servizio OGC
Si prospettano quindi orizzonti interessanti per il GIS open source: attendiamo impazienti e fiduciosi!
Fonte: OpenGeo Blog
MapBox, Cesium, OpenLayers … tutto in 3D!
Già nell’annuncio di OpenLayers 3 era stata dichiarata l’integrazione con Cesium, una libreria Javascript per la creazione di globi 3D (e mappe 2D), in un web browser senza l’utilizzo di plugin che utilizza le WebGL (e quindi necessita di browser di nuova generazione …..), con l’obiettivo di essere cross-browser.
Viene distribuito in modalità open source sotto licenza Apache 2.0, e il suo utilizzo è free per tutti gli usi, commerciali e non.
Ora stanno uscendo i primi samples come questo che permette di vedere affincate (e sincornizzate …), una mappa 2D ed un globo 3D ….
….. o come questo che permette di avere a disposzione i tool di editing tipici di OpenLayers ma questa volta su un globo.
E’ qyuindi possibile immaginare a breve delle web application basate su OpenLayers 3 che permetteranno di avere anche possibilità di rappresentare dati su globi 3D.
In realtà sembra che sulla carta le combinazioni e le opportunità possibili non siano solo queste: considerando infatti che in OpenLayers 3 una delle possibili fonti dati supportate siano anche i tiles di MapBox
e che giusto oggi è uscito un post sul sito di Cesium che annuncia la possibilità di caricare i tiles di MapBox su globi di Cesium
corredato dal fatto che (sito testualmente ….), ” …. If you have a MapBox account, you can view your own maps in 3D. In MapBox, copy the Map ID from the mapbox.js tab on the Publish page, and paste it into the text box in the upper right …..” ecco che la cosa si fa molto interessante per chi voglia, o abbia necessità, di far visualizzare dei propri dati su un globo 3D.
Via MapBox può quindi pubblicare la propia mappa e poi utilizzare Cesium per avereun globo 3D su cui “appoggiare” la propria mappa in cloud.
Se poi a questo aggiungiamo la potenziale opportunità di una integrazione con OpenLayers 3 e quindi la possibilità di costruirsi delle proprie web applicaztion di web mapping o web gis (ma non solo, si deve tenere anche presente l’apertura di OpenLayers 3 verso il mondo mobile …), ecco che è possibile ipotizzare una soluzione, di ottimo livello, che si basa completamente su uno stack open source.
Open Layers 3: ora in alpha version!
E’ ufficiale: Open Layers 3 è ora in alpha version e quindi disponibile per i test.
Sono disponibili gli esempi e la prima versione (incompleta), della documentazione delle API.
Libri e presentazioni open sui GIS
Recentemente sono apparse in rete alcune news sulla disponibilità open di libri e presentazioni su tematiche GIS.
Eccone i riferimenti:
- An Open Geospatial Textbook: autore David Di Biase direttamente da Pennsylvania State University (fonte: @aborruso)
- Map Projections: A working Manual: autore John Snyder dell’USGS (fonte: @aborruso)
- Online GIS: autore Christopher Brown (fonte: GIS Lounge)
- Once Upon a Time …. OpenLayers: autore Antonio Santiago. Bella presentazione di OpenLayers con riferimenti ad esempi tratti dal libro OpenLayers Cookbook (fonte: @cedricmoullet)
Open Layers 3 Sprint Code a Losanna
Direttamente dal blog di OpenLayers è stato riportato un sommario di un recente spint code di OpenLayers 3.
Nel corso dello sprint è stato svolto un interessante lavoro sul vector branch ottenendo i seguenti risultati (riporto integralmente dal post originale):
- GeoJSON format support.
- Tile-based rendering of vector geometries to a 2D canvas.
- Rendering of points with a circle symbol or icons from image files.
- Stroke symbolizers (color, width, opacity) for lines and polygons.
- Fill symbolizers (color, opacity) for polygons.
- Rule based styling with filters and access to feature data, including support for multiple symbolizers per feature
- Fast rendering thanks to spatial R-Tree indexing and rendering of geometries with the same symbolizer in a single pass.
E’ stato fatto anche del lavoro sul fronte del supporto dei formati che è uno dei punti di forza di OpenLayers2. Ora sono supportati OGC Exception Report, OGC OWS Common, OGC WMS Capabilities, OGC WMTS Capabilities, e GeoJSON. E’ stato fatto anche del lavoro sul KML parser ma non è ancora pienamente supportato.
A livello di formati supportati ora OpenLayers 3 ora c’è anche il supporto del WMTS: ora è anche possibile creare WMTS source objects da WMTS Capabilities.
A livello di controlli ora sono disponibile due nuovi controlli interamente customizzabili via CSS: zoom slider e scale line control.
Sono state apportate anche delle migliorie sulle interazioni quali DragPan, TouchPan, and TouchZoom.
OpenLayers 3 ora supporta tre tipi di renderer: DOM, Canvas e WebGL. DOM e WebGL sono stati scritti per primi, successivamente il gruppo di lavoro si è concentrato su Canvas che però deve essere ancora ottimizzato. In molti esempi il renderer può essere settato esplicitamente utilizzando un parametro nella URL, ad esempio la demo dell’utilizzo di Stamen che utilizza il Canvas renderer risponde a questa url
http://openlayers.github.com/ol3/master/examples/stamen.html?renderer=canvas
A livello di API il lavoro sembra ancora essere lungo ma inziano a vedersi i primi risultati. Ora è possibile:
- passare un array di layers al map constructor
- passare dei controlli da attivare sulla mappa
- usare le stringhe per specificare le proiezioni
Un grande miglioramento a livello della qualità del codice dovrebbe essere portato dalla “continuous integration” (vedi Travis CI), che dovrebbe verificare che i vari esempi funzionino sempre correttamente sollevando le opportune eccezioni in caso di errori.
E’ possibile vedere OpenLayers 3 “in action” dalla pagina degli esempi attiva su GitHub.
Fonte: OpenLayers Blog
OpenGeoData: come utilizzarli su una mappa? Ad esempio sfruttando il cross layer filtering di Geoserver
Sempre più spesso si parla di open data e tra questi di quelli che maggiormente sono ricercati dagli utenti, vale a dire quelli georiferiti.
La disponibilità di open dati open georiferiti sta infatti pian piano aumentando come testimoniato nella recente conferenza sugli OpenGeoData tenutasi a Roma il 28 Febbraio. Gli ultimi esempi degni di nota in tale direzione sono stati la pubblicazione in modalità open data di informazioni georiferite messe a disposizione del Comune di Venezia, e da quello di Trento, mentre, ancora più recente, è la notizia relativa alla volontà di prossima pubblicazione in modalità open dei dati georiferiti della Provincia Autonoma di Bolzano.
L’aumentare della disponibilità va sicuramente a “saziare”, in parte, l’appetito di quel mondo di tecnici e appassionati che per skill personali, sanno cosa farci e come usare questi dati ma resta tutto un mondo di potenziali utenti (privati ma anche del mondo business), che, non provenendo dal mondo GIS classico o della neo-geography, non hanno quindi dimestichezza con questa tipologia di dati e che quindi non sa bene come usarli o nemmeno, cosa peggiore, cosa si potrebbe fare per costruirci del valore aggiunto.
Resta quindi un gap da riempire, anche di conoscenza, per valorizzare questo patrimonio informativo messo liberamente a disposizione che, se non colmato, rischia di vanificare in parte il grosso sforzo che si sta facendo negli ultimi anni per rendere open data più informazioni possibili, le quali rischiano sì di uscire dal cassetto di un qualche funzionario della P.A, ma per finire, dimenticati, su un qualche portale open data che con il passare del tempo perderà di interesse.
Esempio
Lo scopo di questo post è quello di illustrare un possibile utilizzo di tali dati sfruttando le funzionalità di cross-layer filtering offerte da GeoServer.
I dati
Come dati di esempio ho utilizzato due shapefile messi a disposizione dal Comune di Torino e precisamente:
- il livello informativo dei numeri civici. Il Comune di Torino censisce infatti in modo puntuale tutti i numeri civici presenti sul territorio comunale e li rende disponibili in scarico in formato ESRI shapefile dal suo portale degli open data AperTO con licenza IODL v20. Il dato è costituito da più di 43.000 punti.
- il livello informativo degli esercizi commerciali. Il Comune di Torino censisce infatti in modo puntuale tutti gli esercizi commerciali presenti sul territorio comunale e li rende disponibili in scarico in formato ESRI shapefile dal suo GeoPortale con licenza Creative Commons public licence” Attribuzione – 2.5 (ITALIA). Il dato è costituito da più di 27.000 punti.
I dati sono praticamente direttamente utilizzabili: per mia comodità ho aggiunto ad entrambi i dati, visto che ne erano privi, un campo chiave univoco (KEY), numerico che ho valorizzato con un progressivo e poi ho trasformato l’SRS di riferimento adottando l’EPSG:900913. Per fare queste operazioni ho utilizzato QGIS Desktop ma sono operazioni che si possono fare con qualunque strumento GIS Desktop.
Per chi volesse replicare gli esmepi riportati in questo post i dati sono liberamente scaricabili.
Cross Layer Filtering in GeoServer
Come ho anticipato in questo esempio ho sfruttato la funzionalità di cross-layer filtering offerte da GeoServer. Questa funzionalità permette di ricercare features di un layer (A) che abbiano una qualche relazione spaziale con features di un altro layer (B).
In generale quindi permette ad esempio di cercare tutte le stazioni di autobus (layer A) che sono entro una certa distanza da un certo negozio (features del layer B), oppure che sono dentro un certo quartiere (layer B).
Ho utilizzato un pc Windows 7 con 4 core e 8 Gbyte di RAM con GeoServer 2.2.3 con le seguenti caratteristiche:
- Git Revision 0fd3212ede1a8e13257ae5785cc8a752ee0a645c
- Build Date 22-Dec-2012 15:59
- GeoTools Version 8.5 (rev 06286dc3c15c2498aa5b3580de5df928f07d31dc)
Nello specifico l’esempio che ho implementato permette di individuare quali sono gli esercizi commerciali che sono nell’intorno di un certo indirizzo.
La funzionalità è stata implementata completamente in GeoServer quindi come funzionalità server-side esposta come WFS quindi potenzialmente fruibile da qualunque client in grado di mandare la richiesta secondo questo protocollo (con i corretti parametri ovviamente), interpretandone poi il GML ottenuto come risposta.
Ecco la chiamata POST nel caso in cui si cerchino le features del layer AttivitaCommerciali che rcadono nell’intorno di 100 metri dal numero civico identificato con la chiave 36748
<wfs:GetFeature
xmlns:wfs=”http://www.opengis.net/wfs”
xmlns:CesareWorkspace=”http://www.openplans.org/spearfish”
xmlns:ogc=”http://www.opengis.net/ogc”
service=”WFS” version=”1.0.0″>
<wfs:Query typeName=”CesareWorkspace:AttivitaCommerciali900913″>
<ogc:Filter>
<ogc:DWithin>
<ogc:PropertyName>the_geom</ogc:PropertyName>
<ogc:Function name=”collectGeometries”>
<ogc:Function name=”queryCollection”>
<ogc:Literal>CesareWorkspace:NumeriCivici900913</ogc:Literal>
<ogc:Literal>the_geom</ogc:Literal>
<ogc:Literal>KEY = 36748</ogc:Literal>
</ogc:Function>
</ogc:Function>
<ogc:Distance units=”meter”>100</ogc:Distance>
</ogc:DWithin>
</ogc:Filter>
</wfs:Query>
</wfs:GetFeature>
Il tutto lo potete eseguire dal Demo Request che trovate una classica installazione di GeoServer in
usando come url per l’esecuzione qualcosa di questo genere
http://localhost:8080/geoserver/CesareWorkspace/ows?
(in questo caso il mio layer si trova in un workspace denominato CesareWorkspace.
Il risultato sarà un GML con l’elenco delle features individuate dal filtro spaziale DWithin: faccio notare che nel GML sono restituite non solo le coordinate delle features ma le intere features come oggetti e quindi comprensive dei dati alfanumerici descrittivi
Un esempio di utilizzo in OpenLayers
Per poter visualizzare questo risultato ho utilizzato OpenLayers 2.12 scrivendo una piccola applicazione web che illustra come visualizzare i dati di partenza, Numeri Civici e Attività Commerciali su sfondo OpenStreetMap e che al tempo stesso permette all’utente di selezionare un indirizzo e sulla base di questo indicare una distanza di ricerca: confermando l’operazione l’applicazione esegue una chiamata in POST verso GeoServer e ne visualizza i risultato sotto forma di VectorLayer di OpenLayers tratto dal GML di risposta.
L’intero codice dell’applicazione è scaricabile e liberamente utilizzabile. Il codice è ampiamente commentato e quindi dovrebbe essere piuttosto chiaro (ovviamente per chi conosce OpenLayers …), il suo modo di operare.
Ecco solo alcune note importanti per la sua esecuzione:
1) se Apache e GeoServer sono su server diversi o sono sullo stesso server ma rispondono su porte diverse è necessario usare un proxypass definito nell’httpd.conf di Apache. Nel mio caso Apache e GeoServer sono sullo stesso server ma Apache risponde sulla porta 80 mentre GeoServer sull’8080 e quindi nel file ci configurazione di Apache ho riportato quanto segue:
<Location /local-geoserver/>
ProxyPass http://localhost:8080/geoserver/
ProxyPassReverse http://localhost:8080/geoserver/
</Location>
2) come anticipato i due layers adottano il sistema di riferimento EPSG:900913. Questa è stata una semplificazione voluta visto lo scopo didattico dell’esempio. Se si intende replicare ed adattare l’esempio con latri dati occorre tenere presente il sistema di riferimento adottato e fare le opportune modifiche
// *****************************************************************
// ** Set up projection used **
// *****************************************************************
var map_projection = new OpenLayers.Projection(“EPSG:900913”);
var map_display_projection = new OpenLayers.Projection(“EPSG:900913”);
e nella definzione del layer la riga
projection: new OpenLayers.Projection(“EPSG:900913”)
3) ad ogni cambio di indirizzo e/o di distanza di ricerca è necessario aggiornare la mappa ma al tempo stesso occorre anche eliminare le features precedentemente disegnate: nel mio caso ho deciso di essere un po “drastico” eliminando e ricreando i layer interessati ogni volta
// ***********************************************************************************
// ** Remove overlay layers: I’ve to update them …. **
// ***********************************************************************************
if (my_address_wfs != null) {
layers = map.getLayersByName(‘Indirizzo in esame’);
for(layerIndex = 0; layerIndex < layers.length; layerIndex++)
{
map.removeLayer(layers[layerIndex]);
}
}
if (my_address_wfs != null) {
layers = map.getLayersByName(‘Attività Commerciali vicino ad indirizzo’);
for(var layerIndex = 0; layerIndex < layers.length; layerIndex++)
{
map.removeLayer(layers[layerIndex]);
}
}
4) occorre considerare che la chiamata verso geoserver e la successiva elaborazione della risposta è un processo asincrono per cui si perde un po’ il controllo del flusso di esecuzione che è demandato completamente ad OpenLayers: può essere quindi un po’ complicato disegnare le features al momento giusto, effettuare i corretti zoom (le features potrebbero non ancora essere state disegnate e il layer risulta “vuoto” ….), ecc .. Nel mio caso per il layer che rappresenta il mio indirizzo in esame (my_address_wfs) ho deciso di utilizzare una strategia Fixed
strategies: [new OpenLayers.Strategy.Fixed()]
e un listener che “scatta” quando tutte le features sono state aggiunte così da poter fare, solo a quel punto, le necessarie considerazioni e azioni, nello specifico fare uno zoom all’indirizzo in esame solo se non siano state individuate attività commerciali nell’intorno dell’indirizzo stesso.
eventListeners: {
“featuresadded”: function(event) {
if (theAttivitaExtent == null) {
this.map.zoomToExtent(this.getDataExtent());
}
}
}
Non potendo mettere a disposizione una versione live dell’esempio in oggetto eccovi un filmato di una sessione di utilizzo
(doveroso … un ringraziamento a Fabrizio C., Diego S. e Fabrizio M., in memoria dei vecchi tempi e per la pazienza ed il supporto che mi hanno dato nella realizzazione di questo esempio di fruizione in OpenLayers)
Conclusioni
Questo è solo un esempio ma illustra un principio di utilizzo che si può estendere e generalizzare, ad esempio:
- il fatto di sfruttare una funzionalità offerta server-side da GeoServer basata su protocolli standard (WFS, GML), permette di riusare la funzionalità stessa da client diversi, sfruttando anche, in caso di necessità, la scalabilità server side offerta dal motore GIS
- la stessa applicazione, pur didattica, sarebbe portabile su un dispositivo mobile. In questo caso la scelta dell’indirizzo potrebbe essere facilmente sostituita dalla posizione corrente dell’utente via localizzazione GPS
- i dati messi a disposizione potrebbero essere più significativi di quelli utilizzati nell’esempio per rendere più utile l’applicazione stessa. Ad esempio localizzazione di servizi di pubblica utilità (ad esempio nel caso in cui si sia in una città che non si conosce …), offerte di business nel campo del commercio (quali negozi offrono quali opportunità nell’intorno di un indirizzo o posizione … ), micro-marketing (caratteristiche dell’utenza nell’intorno di un indirizzo o in un’area), ecc ..
- utilizzo di altre tipologie di filtro spaziale
OpenLayers 3: primi esempi su GitHub
Inizia a vedersi qualcosa di OpenLayers 3: i primi esempi sono disponibili su GitHub da dove è anche possibile scaricarli e farli eseguire in locale.
Per utilizzare completamente gli esempi è opportuno utilizzare un browser che supporti ad esempio WebGL: a tale proposito si veda l’esempio Side-by-side
Fonte: @_giohappy_
Mappe e Open Data del Comune di Vicenza: un esempio interessante
Oggi è apparso su GeoFunction un interessante post che illustra il SIT del Comune di Vicenza e il relativo portale degli Open Data del Comune di Vicenza.
A prima vista può sembrare l’ennesimo annuncio, oramai un SIT web di una P.A non fa quasi notizia e anche dei portali degli open data un po’ ci stiamo facendo l’abitudine: in questo caso però i due progetti hanno delle caratteristiche che meritano una menzione speciale.
Vediamo prima il SIT:
- prodotto informatico sviluppato in house con il supporto del software libero open source:
- LINUX
- DEBIAN LINUX SERVER
- APACHE
- POSTGRESQL
- MAPSERVER
- OPENLAYERS
- PHP
- utilizza come mappa di sfondo OpenStreetMap a cui il Comune di Vicenza, nel 2009, in un’ottica di “open data”, ha messo a disposizione i propri dati cartografici
- consente di conoscere gli estremi catastali associati al proprio numero civico, il percorso di ogni via e tutti i suoi civici
- di un’area selezionata si possono conoscere i dati demografici, la toponomastica e la rete geodetica
Sul portale degli open data:
- i dati del territorio sono resi disponibili in formato ESRI shapefile
- sono resi disponibili, tra gli altri, i livelli informativi Edifici e Numeri Civici direttamente come shapefile (finalmente!)
- sono resi disponibili tutti gli istituti scolastici georiferiti (finalmente!)
- sono resi disponibili i pubblici esercizi, il commercio fisso e le farmacie georiferite (finalmente!)
Fonte: GeoFunction
OpenLayers 3: ecco la roadmap!
Nel post in cui annunciavo il call for funding di OpenLayers 3 sottolineavo che non veniva fornita alcuna roadmap.
Bene, ora ci siamo, eccola direttamente da Tim Schaub, CTO di OpenGeo !
Fonte: Thomas gratier
Cesare Gerbino GIS Blog 