OpenStreetMap: mapping party a Terlizzi

OSMQuake

A quasi tre mesi dalla presentazione ufficiale ad OSMit, pubblico finalmente il codice di OSMQuake purtroppo ancora incompleto e con il codice ancora molto sporco e incasinato (l’ho scritto in tre ritagli di tempo la sera tardi).

Ho aspettato così tanto perché mi sarebbe piaciuto completare alcune parti del software che avevo implementato soltanto in parte purtroppo però in questo periodo non ho molto tempo e preferisco pubblicare il codice in modo che chiunque voglia contribuire (anche per disegnare un logo ad esempio) possa farlo.

Il codice sorgente si trova attualmente qui, se qualcuno volesse collaborare posso metterlo su google code e usare svn per la gestione della versione.

Questo è il risultato dell’elaborazione di stamattina sull’Italia centrale.

mappa terremoti luglio 2009 Italia centrale

Già dalla mappa è possibile vedere cosa manca:

• Il raggio del marker è direttamente proporzionale alla magnitudo ma il colore dovrebbe essere inversamente proporzionale al tempo, cosicchè i terremoti più recenti siano di un rosos più intenso.
• Sarebbe bello avere una didascalia con qualche indicazione riguardo i range di dimensioni e di colori e delle statistiche generate automaticamente

Per generare la mappa precedente basta avviare OSMQuake e poi premere sul tasto “Scarica” per effettuare il parsing della pagina e salvare gli eventi in un database sqlite (notare in basso a sinistra il numero degli eventi scaricati):

Interfaccia grafica OSMQuake

A questo punto si possono scegliere i parametri di filtraggio, lo zoom della mappa e il tipo di mappa (Mapnik, Osmarender e OpenArial) e si clicca su Genera mappa. A questo punto il software mostra le tile da scaricare e le dimensioni della mappa in pixel e inizia a scaricare le tile necessarie. Dopo di che le unisce e disegna sopra la mappa i marker calcolando dinamicamente il raggio.

Il risultato finale è una nuova finestra con la mappa:

Mappa finale

Mappa finale2

Cosa funziona in OSMQuake:

• Parsing della pagina
• Riempimento del database con gli eventi
• Filtraggio per magnitudo
• Filtraggio per profondità
• Scelta dello zoom
• Scelta del server
• Calcolo delle tile da scaricare
• Calcolo delle dimensioni della mappa in pixel

Cosa non funziona (ancora!) in OSMQuake:

• Filtraggio degli eventi in base alla distanza da un punto geografico
• Calcolo dell’area coperta dalla mappa
• Filtraggio in base alla regione (ho già i bbox delle regioni italiane che mi ha dato Niccolò Rigacci ma non ho avuto il tempo di creare un dizionario con i bbox)
• Per generare una nuova mappa con la stessa istanza è necessario cancellare a mano le tile (io uso uno script in bash)
• Prima di scaricare di nuovo gli eventi è necessario cancellare il file del database (il file prova)

Cosa sarebbe mi piacerebbe implementare in OSMQuake:

• Riscrivere il codice ad oggetti
• Implementare il threading per lo scaricamento delle tile (la policy del tile server di OpenStreetMap permette solo due thread)
• Permettere di mantenere un database storico degli eventi e di filtrarli anche per periodo per creare delle mappe mensili o settimanali di una determinata zona
• Permettere l’esportazione deglio eventi sismici in KML

Qualsiasi contributo è benaccetto!

Cambiare la cartella di salvataggio delle mappe di TangoGPS su OpenMoko

TangoGPS è sicuramente uno dei migliori software di tracking disponibili su OpenMoko, tra le tante funzioni utili sicuramente la migliore è quella di poter visualizzare la posizione attuale e il percorso che si sta tracciando sulle mappe di OpenStreetMap.

Purtroppo la memoria interna dell’OpenMoko è limitata e non è possibile, ad esempio, scaricare tutta l’Italia al livello massimo, per cui è comodo salvare le mappe sulla memory card esterna. Se si prova a cambiare il percorso di storage dalla tab config di TangoGPS, il software restituisce un errore di segmentation fault e va in crash.

Per cambiare la cartella di salvataggio dal terminale, basta loggarsi via ssh all’OpenMoko e digitare:

gconftool-2 -s /apps/tangogps/repos \
"[OSM|http://tile.openstreetmap.org/%d/%d/%d.png|/media/card/Maps/OSM|\
0,Topo|maps-for-free|/media/card/Maps/maps4free|\
0,Aerial|openaerial|/media/card/Maps/openaerial|\
0,Opencyclemap|http://a.andy.sandbox.cloudmade.com/tiles/cycle/%d/%d/%d.png|/media/card/Maps/opencyclemap|\
0,Google Sat (testing only)|http://khm1.google.com/kh?v=34&hl=en&x=%d&s=&y=%d&z=%d|/media/card/Maps/googlesat|1]" \
--type list --list-type string

OSMit 2009

Che dire di OSMit 2009? Semplicemente un’esperienza fantastica che ha riunito buona parte delle persone che gravitano intorno al progetto.

Guest star è stato il fondatore stesso di OpenStreetMap – Steve Coast – con cui non poteva mancare una foto che è stato così gentile sa spiegarmi personalmente come funziona il tile cache server personalizzato di Cloudmade.

Durante i due giorni della conferenza si sono discussi temi importanti e ci sono state dimostrazioni reali di possobili applicazioni di mappe e dati messi a disposizione dal progetto OpenStreetMap.

Io ho presentato il software OSMQuake, di cui a breve rilascerò il codice, per visualizzare gli ultimi eventi sismici dell’Istituto Nazionale di Geofisica sulle mappe di OpenStreetMap.

Di seguito poteve visualizzare le slide con slideshare e da scaricarle da qui.

Visualizzare gli ultimi eventi sismici dal sito INGV (usando OpenStreetMap)

Stamattina un amico (TheDom), studente dell’Università dell’Aquila fortunatamente scampato al terremoto, mi ha chiesto di aiutarlo a creare uno script che si interfacciasse con il sito dell’Istituto Nazionale di Geofisica e Vulcanologia e che visualizzasse i dati degli ultimi eventi sismici e restituisse un link ad OpenStreetMap per visualizzare la cartina.

Guardando il codice dell’homepage del sito mi sono accorto che i singoli eventi erano racchiusi nel tag <tr class=”print_light”> e i dati dell’evento erano racchiusi nei tag figli <td class=”td_events”>.

<tr class="print_light"  [...]>
<td class="td_events">1206577780</td>
<td class="td_events">&nbsp;</td>
<td class="td_events">2009/04/11</td>
<td class="td_events">16:18:34</td>
<td class="td_events">42.264</td>
<td class="td_events" width="45px">13.486</td>
<td class="td_events">9</td>
<td class="td_events">Ml:2.8</td>
<td class="td_events">&nbsp;</td>
<td class="td_events">Valle_dell'Aterno</td>
</tr>

Considerata la regolarità del codice, ho sfruttato le potenti funzionalità del modulo di parsing BeautifulSoup, per raccogliere facilmente i dati dal sito.

Il cuore dello script è costituito dalla funzione DataCollect che, preso il codice della pagina in input, trova tutti i tag che corrispondono a <tr class=”print_light”>. In seguito, cercando all’interno dei singoli tag <tr>, restituisce, sotto forma di lista, il testo contenuto nei tag figli <td>.

def DataCollect(pagina,id):
     """Restituisce una lista con i dati desiderati"""
     lista = []
     dati = pagina.findAll('tr',attrs={"class":"print_light"})[id]
     dati = dati.findAll('td',attrs={"class":"td_events"})
     for i in dati:
     lista.append(i.string)
     return lista

La riga di codice numero 4 trova tutti i tag tr avente gli attributi definiti nel dizionario {“class”:”print_light”} passato come variabile. Considerando che l’istanza findAll dell’oggetto pagina restituisce, sotto forma di tupla, il contenuto dei singoli tag tr, è possibile accedere al contenuto di un solo tag tr usando gli indici della tupla (il numero tra parentesi quadre). Dopodiché è possibile rieseguire una seconda istanza findAll sull’oggetto dati (riga 5), che come abbiamo visto in precedenza contiene solo il contenuto di un solo tag, cercando questa volta tutti i tag td. A questo punto l’oggetto dati è una tupla contenente tutti i tag td, figli del tag tr (quelli mostrati nel codice html precedente). Infine basta iterare all’interno di questa tupla (riga 6), assegnando ad una lista (inizializzata alla riga 3) il contenuto dei signoli tag td ottenuti attraverso l’istanza string (riga 7).

La funziona Parsing legge semplicemente il contenuto della pagina html e lo passa a BeautifulSoup per l’elaborazione.

def Parsing(link):
     """Restituisce il parsing della pagina"""
     try:
         socket = urlopen(link)
         testo = BeautifulSoup(socket.read())
         socket.close()
     except:
         return ("""Si è riscontrato un errore durante l'apertura del link, prima \
         di procedere:\t
         1) controllare la connessione ad internet\t
         2) assicurarsi che il link esista\t
         3) assicurarsi che il link sia scritto correttamente (ricordarsi di scrivere \
         anche http://)\t
         4) controllare i permessi per accedere alla rete.""")
 return testo

Alla riga 5 la funzione apre il link dell’home page dell INGV e alla riga 6 l’istanza read(), che restituisce il contenuto html della pagina, viene passata all’elaboratore BeautifulSoup.

Infine l’ultima funzione, formatta l’output in maniera colorata e più “umana” sfruttando il modulo scritto da Checkm.

def HeartquakePrint(lista):
     """Formatta e stampa i dati dell'evento sismico"""
     print cms.color("<red>Dati riepilogativi evento sismico</red>")
     print cms.color("<green>Link diretto:</green>   <yellow>http://cnt.rm.ingv.it/~earthquake/data_id/%s/event.php</yellow>") % lista[0]
     print cms.color("<green>Data:</green> <yellow>%s</yellow>") % lista[2]
     print cms.color("<green>Ora:</green> <yellow>%s</yellow>") % lista[3]
     print cms.color("<green>Latitudine:</green> <yellow>%s N</yellow>") % lista[4]
     print cms.color("<green>Longitudine:</green> <yellow>%s E</yellow>") % lista[5]
     print cms.color("<green>Link OpenStreetMap:</green> <yellow>http://www.openstreetmap.org/?lat=%s&lon=%s&zoom=17&layers=B000FTF</yellow>") % (lista[4],lista[5])
     print cms.color("<green>Magnitudo:</green> <yellow>%s</yellow>") % lista[7]
     print cms.color("<green>Distretto sismico:</green> <yellow>%s</yellow>\n") % lista[9]

Il modo più semplice per eseguire lo script (sia su windows che su linux) è quello di scaricare l’archivio contenente tutti i file necessari all’esecuzione da qui. Scompattarlo ed eseguirlo digitando in un terminale:

$: python script.py

Questo è il risultato finale:

Quando le strade si incrociano: OpenStreetCamping 10 giorni dopo

Questo è il messaggio, scritto a tre mani con Fradeve (ha scritto praticamente tutto lui, per cui io ho messo solo una mano ), inviato alla mailing list italiana di OpenStreetMap (link al messaggio) come resoconto dell’OpenStreetCamping.

Quando le strade si incrociano:
OpenStreetCamping – 10 giorni dopo…

Al termine dell’OpenStreetCamping, ci sembrava doveroso stendere un resoconto dei fatti accaduti (e anche di quelli mai ufficialmente avvenuti). Non ci piace perderci in chiacchiere, ma a volte capita che i particolari di una storia esprimano alcuni concetti meglio della storia stessa.
La partenza, fissata per le ore 8.00 del 4 Agosto 2008, è stata meno complicata del previsto, complice il sonno (la sera prima ricorreva la festa patronale del nostro paese natale, Terlizzi, con bagordi vari). Il viaggio è stato accompagnato da musica blues e folk.
Prima tappa: Cerignola, dove abbiamo trovato ad aspettarci il simpaticissimo – e precisissimo – Niubii aka Francesco. La sua gentilezza è stata molto lungimirante, visto che ci ha offerto una colazione con i fiocchi prima ancora che avessimo cominciato a mappare anche solo 2 metri di strada

Potete immaginare quanto potesse risultare astrusa la conversazione tra tre mapper alle orecchie degli altri avventori del bar. Complice la chiarezza e la simpatia di Francesco, la prima tappa è durata la bellezza di un paio d’ore. Abbiamo avuto anche occasione d’ammirare il Garmin di Francesco, bestiola GPS da 500gr che tutti quanti vorrebbero avere… in tasca.
Salutando a malincuore Francesco, e scansato qualche *piccolo* inconveniente legato alla fuga di gas dalla bombola del fornello da campo (che era sotto i 40°C della macchina al sole), ci siam rimessi in viaggio. Dopo una piccola sosta all’interno della Foresta Umbra con annesso spuntino chimico, siamo arrivati al tourism=campsite alle 15.00. Il primo pomeriggio è morto nel montaggio della tenda e in un salutare bagno a mare, che distava dal waypoint tenda la bellezza di 2000 m. Abbiamo approfittato della serata sulla spiaggia per instaurare tra me e Alessandro una stretta amicizia alcolica, complice il vino portato da Alex (che, ricordiamolo per delicatezza, tra 4 mesi si laureerà in Enologia). Che vi piaccia o no, in questa mail saremo schietti: il mio soprannome da quella sera è diventato “vomitino”.

Le mattine tra il secondo ed il quarto giorno sono state legate praticamente sempre all’attività di mapping: a San Menaio abbiamo tirato su i gpx per il lungomare, una pineta, una farmacia, e molte delle strade che circondano la zona. Con le biciclette ci siamo spinti fino a Rodi Garganico, mappando molte strade della cittadina. Sfortuna ha voluto che quel giorno il mio cellulare (Nokia 6630 collegato ad antenna GPS bluetooth Hamlet) desse di matto, perdendo il gpx. Delusione amara e forte frustrazione (affogate nell’acool, ovviamente). Per la prima volta, abbiamo cercato di procedere con un mapping serio: Alex si è armato della mia Moleskina per prendere nota dei nomi delle strade, cosa che fino ad allora non era successa molto di frequente (soprattutto perchè non ce n’era mai stato bisogno).

Il secondo giorno di permanenza a San Menaio è stato allietato dall’arrivo di Simone Cortesi (un simpatico pavese con la mania per Lino Banfi). Ci riesce difficile trovare le parole per descrivere Simone: in linea generale il suo presentarsi con la maglietta nera dello State of the Map 2008 ha generato in noi un lieve senso di devozione verso quel mapper. Nel giro di un paio di giorni siamo stati in grado di affrontare conversazioni in cui si passava allegramente dal rendering di InformationFreeway alla lievitazione dei panettoni, per non parlare dei processi di vinificazione e di tutta la teoria sugli aceti. E non si dica che i geek sono noiosi

Scherzi a parte, Simone è stata per noi la finestra sul mondo di OSM, come non ne avevamo mai avute; la sua esperienza dello SOTM 2008 – anche se per via puramente fotografica – ci ha permesso di conoscere alcuni volti importanti dell’evento ed alcune situazioni veramente spassose che hanno a che fare con l’intervento di Google alla manifestazione irlandese. Per saperne di più, offrite una birra a Simone, lui sarà felicissimo di raccontarveli
Oltre ad una buona forchetta, l’arrivo di Simone ha portato un pò di mobilità: mentre in sua assenza ci siamo mossi praticamente solo in bicicletta (si stimano 140 km in mountain bike in 10 giorni, non molto, in fondo…), la sua Volvo ci ha guidati su molte strade che altrimenti non avremmo mappato. Degni di nota sono anche alcuni pomeriggi di pura pigrizia trascorsi in *geek sessions*; si è anche scoperto che Ruvo di Puglia è un feudo di Terlizzi (ma questa è un’altra storia). In generale, non penso che il tavolo da campeggio di Alex abbia ospitato tanta elettronica tutta insieme come in quei pomeriggi: 2 portatili, 3 cellulari, 2 navigatori GPS, 2 macchine fotografiche ed un numero imprecisato di periferiche di memorizzazione di massa.
Degna di nota è stata anche l’”escursione” (se così vogliamo chiamarla) a San Giovanni Rotondo, per mappare la Basilica di San Pio, di recente costruzione. Non voglio far trasparire opinioni personalissime, ma il nostro terzetto è stato perfettamente daccordo sul fatto che la chiesa sembrasse più un Auchan della fede che un luogo di culto. Poi, abbiamo delle foto superbe dei distributori di lumini a gettoni. Però, bisogna ammetterlo: abbiamo mappato la più grande area “pedestrian” della Puglia (se non d’Italia) costringendo il nostro “antennoforo” (Alex, tolkienianamente detto “portatore dell’antenna”) a seguire per filo e per segno il perimetro dell’area pedonale antistante la basilica. Erano le 10.00 PM. Di quei momenti credo che Simone abbia scattato foto molto eloquenti, ahynoi
Quella sera stessa ci siamo rifugiati in un anonimo pub nell’anonimo paesino di Cagnano Varano e, andando vicino alla cassa per ordinare da mangiare, siamo subito rimasti di sasso nel constatare che sul pc era in esecuzione Amarok su Ubuntu per diffondere la musica nel locale. Non avremmo mai scommesso neanche un centesimo sul fatto che tre mapper, nel paese meno turistico d’Italia, potessero trovare una cosa del genere (tra l’altro il sottoscritto Francesco è anche un ubuntero).

Ringraziando Simone per il vino, ogni separazione è dolorosa – ma è pur sempre un arrivederci.

I restanti 5 giorni Alessandro e Francesco li han trascorsi a Foce Varano, amena località turistica del Gargano nota soprattutto per le zanzare grandi quanto gatti. A differenza di San Menaio, il posto questa volta presenta strade con pendenza pari allo 0° (contro il 20° medio della località precedente). Ciò ha significato per noi moltissimi km in bicicletta e anche molti file igc da convertire in gpx (senza contare i file nmea che ci aveva passato Simone), stanchi di utilizzare il terminale, Alessandro si è adoperato  -mentre io leggevo la splendida biografia di Torvalds- per scrivere un piccolo script in python per la conversione in massa dei file igc e nmea. Senonchè, Simone decide di venire a trovarci ancora per un paio d’ore in piazza, prima di partire per il profondo Nord (portando anche la brutta notizia delle cagionevoli condizioni di salute del cerignolano Francesco).
In quei giorni abbiamo mappato quasi tutto il paese, poi tutta l’area portuale, poi la riserva naturale che sorge sull’istmo di terra tra lago e mare, poi un pò delle campagne, oltre a vari km di coastline percorsi di notte sulla spiaggia sabbiosa. A due giorni di distanza dal ritorno a casa, la folle decisione di circumnavigare il Lago di Varano. Chiunque abiti su quello di Como, di Garda o sul Trasimeno, non ha idea di cosa sia il lungolago di Varano. Una highway=track quasi completamente sabbiosa larga non più di 2 m, a non più di 40 cm dalla riva del lago. Bella fregatura, farselo in bici. Comunque, siamo riusciti a definire con precisione almeno la costa orientale del Lago (sfuggendo ad un simpatico pastore tedesco dalle dimensioni interessanti, a guardia di una villa lì sul lago).

Il ritorno è stato animato nuovamente dalla musica blues, folk e dall’incontro con Francesco a Cerignola, che questa volta ci ha offerto un rinfresco con cognizione di causa, dopo aver osservato il lavoro svolto (scherzo naturalmente ). Siamo stati molto felici di ritrovarlo in forze ed armato di GPS, nonostante il brutto periodo trascorso mentre noi eravamo a Foce Varano. A lui i nostri saluti e ringraziamenti per la disponibilità

Sicuri di avervi annoiato abbastanza, pensiamo sia il caso di chiudere qui il messaggio. I risultati seri dell’OpenStreetCamping 2008 saranno visibili nei prossimi giorni, probabilmente dopo il rendering settimanale (su freeway si vede già qualcosa). Non voglio azzardare statistiche, ma abbiamo mappato veramente molto (e a questo proposito vorrei ringraziare Simone per le escursioni in auto). Tutte le (innumerevoli) foto sono disponibili sull’account Flickr di Francesco.

In fondo, lo diceva Linus: il senso della vita umana è legato essenzialmente – in ordine – ai concetti di sopravvivenza, socialità, divertimento. Possiamo dire che OSM ci ha permesso di conoscere un paio di mapper (e, tramite loro) una comunità molto più ampia. Per noi, il viaggio ha permesso di soddisfare ben due necessità in una botta sola: socialità e divertimento, dispensate a larghe braccia dalle comunità dei progetti open source.

Auguri a tutta la Comunità Italiana di OSM per il futuro,
e buon mapping

Francesco de Virgilio aka Fradeve11
Alessandro De Noia aka Sdonk

Utilizzare sul proprio pc TangoGPS e le mappe di OpenStreetMap

Se inserire le mappe di OpenStreetMap nel proprio sito/blog è una grande soddisfazione, soddisfazione ancora più grande è vedere le mappe di OpenStreetMap funzionanti su un navigatore GPS.

Nella mailinglist italiana di OpenStreetMap si parlava di OpenMoko e di TangoGPS, il navigatore per palmari scritto in python che utilizza le mappe di OSM, e ovviamente io non potevo resistere alla tentazione di provare il navigatore sul mio pc utilizzando l’antenna esterna che uso per raccogliere le tracce e una penna bluetooth da due soldi.

Se usate Ubuntu (o Debian) è possibile scaricare il pacchetto .deb direttamente dal sito (link diretto) e poi da terminale digitare:

$: sudo dpkg -i tangogps_0.9.2_i386.deb

Una volta installato il software dobbiamo solo collegare l’antenna al demone che gestisce il gps (gpsd), per farlo ho seguito pedissequamente l’ottima guida del blog di michelem.

Una volta configurato il tutto (basta seguire la guida che non riporterò qui) ho avviato TangoGps e mentre iniziavo a cercare il pulsante per scaricare le mappe il software si è agganciato all’antenna e ha scaricato automaticamente le mappe di OpenStreetMap, fenomenale!

Ecco uno screenshot (click sull’immagine per ingrandire), il cerchietto blu è dove si trova la finestra della mia stanza… precisissimo!

Forza che aspettate, correte fuori di casa e mappate tutto quello che vi capita a tiro per avere la soddisfazione di utilizzare le mappe che avrete contribuito a creare.

Inserire mappe di OpenStreetMap nel proprio sito/blog

Qual è la più grande soddisfazione per un mapper se non quella di mostrare i risultati del proprio lavoro sul sito o sul blog personale?

Spulciando il wiki di OpenStreetMap mi sono imbattutto nella pagina OpenLayers Simple Example, in cui è descritta la procedura più semplice per inserire una slippy map standard in una pagina web attraverso uno script in java javascript.

Essendo pythonista convinto di Javascript non capisco molto, ma il codice mi è sembrato molto intuitivo, vediamo insieme il codice della pagina html:

<!-- bring in the OpenLayers javascript library
(here we bring it from the remote site, but you could
easily serve up this javascript yourself) -->
<script src="http://www.openlayers.org/api/OpenLayers.js"></script>

<!-- bring in the OpenStreetMap OpenLayers layers.
Using this hosted file will make sure we are kept up
to date with any necessary changes -->
<script src="http://www.openstreetmap.org/openlayers/OpenStreetMap.js"></script>

<script type="text/javascript"><!--
// Start position for the map (hardcoded here for simplicity,
// but maybe you want to get from URL params)
var lat=41.12925
var lon=16.5449
var zoom=15

var map; //complex object of type OpenLayers.Map

//Initialise the 'map' object
function init() {

map = new OpenLayers.Map ("map", {
controls:[
new OpenLayers.Control.Navigation(),
new OpenLayers.Control.PanZoomBar(),
new OpenLayers.Control.Attribution()],
maxExtent: new OpenLayers.Bounds(-20037508.34,-20037508.34,20037508.34,20037508.34),
maxResolution: 156543.0399,
numZoomLevels: 19,
units: 'm',
projection: new OpenLayers.Projection("EPSG:900913"),
displayProjection: new OpenLayers.Projection("EPSG:4326")
} );

// Define the map layer
// Note that we use a predefined layer that will be
// kept up to date with URL changes
// Here we define just one layer, but providing a choice
// of several layers is also quite simple
// Other defined layers are OpenLayers.Layer.OSM.Mapnik, OpenLayers.Layer.OSM.Maplint and OpenLayers.Layer.OSM.CycleMap
layerTilesAtHome = new OpenLayers.Layer.OSM.Osmarender("Osmarender");
map.addLayer(layerTilesAtHome);

var lonLat = new OpenLayers.LonLat(lon, lat).transform(new OpenLayers.Projection("EPSG:4326"), map.getProjectionObject());

map.setCenter (lonLat, zoom);
}

// --></script>

<!-- body.onload is called once the page is loaded (call the 'init' function) -->

<!-- define a DIV into which the map will appear. Make it take up the whole window -->

Questa è una pagina html completa che integra una slippy map delle stesse dimensioni della pagina html, nel caso vogliate personalizzare il titolo della pagina (quello che compare nella finestra del browser) dovete modificare ciò che è compreso nel tag <title></title>:

Il passo successivo consiste nel modificare le coordinate di origine della mappa e lo zoom di default, dal sito, cliccando su “permalink” in basso a destra dopo aver cercato la città o la regione di interesse e lo zoom gradito e copiando il nuovo indirizzo che nel frattempo sarà comparso nella barra del browser.

Le coordinate e lo zoom vanno inserite in questo punto del file html:

<script type="text/javascript"><!--
var lat=41.12925
var lon=16.5449
var zoom=15

Se intendiamo utilizzare un solo tipo di layer (vedi punto successivo) possiamo lasciare invariata la porzione di script che inizializza gli oggetti della mappa, in caso contrario dobbiamo aggiungere il LayerSwitcher alla mappa per permettere agli utenti di cambiare layer al volo, modificando il codice che inizializza i controlli da così:

new OpenLayers.Control.Navigation(),
new OpenLayers.Control.PanZoomBar(),
new OpenLayers.Control.Attribution()],

a così:

new OpenLayers.Control.Navigation(),
new OpenLayers.Control.PanZoomBar(),
new OpenLayers.Control.LayerSwitcher(),
new OpenLayers.Control.Attribution()],

In questo script è implementato solo il layer di Osmarender (il software di rendering open source nato in casa OpenStreetMap e utilizzato dal progetto di rendering distribuito tiles@home):

layerTilesAtHome = new OpenLayers.Layer.OSM.Osmarender("Osmarender");
map.addLayer(layerTilesAtHome);

Volendo ottenere una mappa più interattiva è possibile aggiungere anche gli altri due layers standard usati da OpenStreetMap nelle mappe del sito:

• Mapnik layer (lo standard di rendering di OpenStreetMap)
• CycleMap (la mappa con le isoipse utili ai ciclisti)

Per aggiungere gli altri due layer è necessario modificare il codice precedente in questo modo:

layerTilesAtHome = new OpenLayers.Layer.OSM.Osmarender("Osmarender");
map.addLayer(layerTilesAtHome);
layerMapnik = new OpenLayers.Layer.OSM.Mapnik("Mapnik");
map.addLayer(layerMapnik);
layerCycleMap = new OpenLayers.Layer.OSM.CycleMap("CycleMap");
map.addLayer(layerCycleMap);

Infine dobbiamo decidere soltanto le dimensioni di visualizzazione della mappa in modo da adattarla al contesto del nostro sito o blog, per fare ciò basta modificare le dimensioni proporzionali della mappa rispetto al <div> in cui è contenuta, in questo caso, essendo su di un file html a parte, ho deciso di lasciare le dimensioni della mappa grandi quanto la pagina html.

<div style="width:100%; height:100%" id="map"></div>

Clicca qui per vedere il risultato finale adattato alla mia città e se sei pigro ti basta fare clic con il destro e scegliere salva con nome per per scaricare il file già modificato, ma ricordati di cambiare almeno le coordinate della mappa!
// –>

Trasformare in massa tracce igc e nmea in tracce gpx

Durante l’openstreecamping2008 abbiamo avuto la necessità di trasformare, con gpsbable, le decine di tracce igc, il formato di tracking che utilizza il cellulare di Fradeve, raccolte durante i giri in bici in formato gpx che è il formato utilizzato da josm.

Dopo qualche giorno ci siamo resi conto che era noioso ridigitare ogni volta il comando dal terminale (ovviamente non tutto, ma modificando semplicemente il nome del file nel comando precedente) e potevamo perdere tempo prezioso in questo modo? Ovviamente no!

Mentre Fradeve leggeva la biografia di Torvalds (ve la consiglio) e il caldo era insopportabile, ho scritto un piccolo script in python per convertire in massa file igc e nmea in file gpx.

Credo sia possibile farlo anche in bash, ma non conoscendo il bash ho preferito usare il python e in particolare il modulo os, contenuto nella libreria standard, che permette al programma di interfacciarsi con il sistema operativo.

Clic qui per scaricare lo script

Qualche commento al codice:

if formato in ListaFormati :
    ListaFile = CercaFile(os.listdir('.') , formato)
else :
    print "Formato inesistente o non ancora implementato, esco dal programma."
exit()

Controlla il formato passato come argomento al programma e, se corretto (i formati accettati sono igc e nmea), restituisce una lista, attraverso la funzione os.listdir(cartella), con tutti i file contenuti nella cartella passata come argomento.

def CercaFile(lista, flag):
    for i in lista:
        if flag in i:
            gpx.append(i)
return gpx

La funzione CercaFile restituisce una nuova lista contenente soltanto i file con l’estensione interessata (igc o nmea), eliminando tutti gli altri file inutili.

if ListaFile != []:
    c = 0
    for i in ListaFile:
        stringa = "gpsbabel -i " + formato + " -f '" + i + "' -o gpx -F '" + i[0:-3] + "'gpx"
        os.system(stringa)
        c = c + 1
    print "Ho trasformato " +str(c)+ " file in gpx ed ho cancellato i file " + formato + ""
else:
    print "Non ci sono file da convertire, ciao!"

Controlla che ci siano file da convertire, in caso positivo passa al sistema, attraverso il la funzione os.system, il comando gpsbabel necessario alla conversione dei file. La stringa che può sembrare complicata serve a trasformare i file mantenendo il nome originale.

Per eseguire lo script basta copiare i file da trasformare nella stessa cartella dove è presente lo script e poi da terminale digitare:

$: python trasforma.py formato

dove formato deve essere sostituito con igc o con nmea a seconda del formato di partenza dei file.

Semplice, veloce ed efficace a patto di aver gpsbabel installato, ovviamente!

Estrapolare dati dai file gpx

Dopo l’avventurosa e faticosissima biciclettata di sabato scorso sulla strada che porta a Castel del Monte (foto), che ovviamente abbiamo mappato (permalink osm), mi sono chiesto quale fosse la variazione di pendenza che le nostre povere gambe hanno dovuto sopportare e mi sono subito messo all’opera per scrivere un rudimentale parser in Python sfruttando il modulo BeautifulSoup (installabile dai repository di Ubuntu)

Avendo più tempo a disposizione mi piacerebbe scrivere l’interfaccia grafica del programmino e far disegnare il grafico ad uno dei potenti widget di wxPython, ma purtroppo adesso devo accontentarmi di questo script molto semplice ma al tempo stesso efficace.

Clic qui per scaricare lo script.

Anche se lo script è semplicissimo aggiungo qualche commento:

</code>

try:
NomeFile = sys.argv[1]
except:
print "Argomento mancante o non valido"
exit()

</code>

try:
gpx = open(NomeFile,'r')
except:
print "Impossibile leggere il file, controllare che lo stesso esista e che sia leggibile"
exit()

</code>

xml = gpx.read()
gpx.close()
soup = BeautifulStoneSoup(xml)
dati = open('dati.txt','w')
n = 0
for i in soup.findAll('ele'):
dati.write(i.string + '\n')
n = n + 1
dati.close()