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!

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!

OpenStreetCamping, edizione 2008

Quest’anno, c’è qualcosa di nuovo sotto il sole estivo. Avete voglia di sole, mare, foreste, ciclismo nella natura? Siete appassionati di campeggio, non vi muovete senza tenda e fornellino? Volete contribuire al più grande (e ben riuscito) progetto di mappatura del mondo conosciuto, OpenStreetMap?

Bene, OpenStreetCamping fa per voi.

Da un’idea mia e del mio compagno (e compaesano) di mapping, Fradeve aka Francesco, abbiamo avviato per la prima volta nella storia di OpenStreetMap un viaggio-campeggio con l’intenzione di montare tenda in molti posti diversi e, servendoci della bicicletta (infilata con la forza nella mia FIAT Panda che utilizzeremo per gli spostamenti) mapperemo quante più strade possibili.

La nostra tenda è da 6 posti, e i mapper da tutto il mondo sono i benvenuti a trascorrere 10 giorni in nostra compagnia. Saremo nel Parco Nazionale del Gargano dal 4 al 13 agosto.

Per riassumere, incollo qui la lettera che abbiamo inviato nella mailing list italiana di OpenStreetMap:

Carissimi Mapper italiani,
siamo due freschi mapper pugliesi che si stanno impegnando a mappare praticamente qualsiasi cosa capiti a tiro in giro per la città in cui viviamo, Terlizzi ed il capoluogo in cui studiamo, Bari. I risultati di 2 mesi di mapping sono visibili qui. Tutto il mapping è fatto completamente in bicicletta, quindi vi lasciamo immaginare quanti km abbiamo fatto in due mesi

Arrivata l’estate, finiti(?) gli esami, abbiamo pensato di andare in campeggio sul Gargano per una decina di giorni. Nello stesso momento in cui abbiamo avuto l’idea del campeggio, ci siamo guardati in faccia e senza aggiungere altro, abbiamo cominciato ad “accarezzare” l’antenna GPS… l’idea ormai era partorita. È così che ci è venuto in mente l’OpenStreetCamping. L’idea (malata) è più o meno la seguente: si parte per un campeggio di 10 giorni, con la mia fedelissima FIAT Panda “Young”, caricata con tutto il materiale del caso, e le nostre fedeli biciclette.
Ci sposteremo per 3 campeggi in 3 località diverse del Gargano:
- Manfredonia
- Vico del Gargano (Google Maps lo chiama “Vicolo” del Gargano XD)
- Peschici
Sosteremo in ognuno di questi campeggi per 3 giorni, passando tutta la giornata in bici per mappare il luogo. Ovviamente, il tutto sarà accompagnato da innumerevoli bagni nello splendido mare pugliese, grigliate di carne locale e buon vino. C’è venuto in mente di chiamare questa cosa OpenStreetCamping, perchè – in fondo – il nostro primo obiettivo, oltre a pedalare e divertirci, è ovviamente mappare (sul Gargano non c’è praticamente niente).

Non sappiamo se l’idea può interessare a qualcuno, se c’è qualche mapper nei pressi di Manfredonia, se qualcuno vollesse unirsi a noi. Solo, ci sembra un’idea carina che tiene alto lo spirito della “Comunità” mapper italiana.
Per l’occasione stiamo cercando di farci stampare delle magliette con i loghi di OSM; nell’attesa, abbiamo personalizzato i nostri caschi da bicicletta con degli adesivi. Tutto il viaggio verrà documentato con foto e “narrazione” giorno per giorno (pubblicati sui nostri blog [5]), ed ovviamente dal caricamento dei GPX su OSM
Considerato che entrambi collaboriamo anche ad alcuni dei progetti della Wikimedia Foundation, il viaggio sarà l’occasione per raccogliere del materiale fotografico che ancora non esiste sulle tre città che visiteremo e sui territori che le circondano. Come dire… sarà un OpenTravel, o qualcosa del genere.

Se avete suggerimenti, idee, proposte, consigli et similia, non esitate a scriverci. Abbiamo in mente di realizzare anche una modesta locandina per pubblicizzare un pò l’idea attraverso i blog.

Saluti,

Francesco [Fradeve11]
Alessandro [Sdonk]

Il casco con adesivi di OSM su entrambi i lati

Mapping delle campagne pugliesi, Fra è perplesso perché credeva che ci fossimo persi… io no!

Chiunque volesse unirsi a noi nell’impresa di mappare (almeno parzialmente) il Parco Nazionale del Gargano, è pregato di contattarci.

Lo stambecco trova la sua strada

A pochi giorni dall’uscita di Hardy è già disponibile la roadmap che porterà il team di Ubuntu a rilasciare, ad Ottobre, la versione 8.10 nome in codice Intrepid Ibex (stambecco intrepido).

Già domani si terrà l’incontro tra gli sviluppatori al Corinthia Towers Hotel di Praga, ed il rilascio della prima alpha è prevista per il sette giugno.

Salvare la banca dati Inran in un file sqlite3

Giocherellando con i moduli di python per la gestione dei database sqlite3, per il parsing delle pagine web e con le espressioni regolari ho scritto un piccolo programmino che permette di effettuare l’html screen scraping delle pagine componenti la banca dati dell’Inran e di salvare i dati riguardanti la composizione nutrizionale di 790 alimenti in un database ordinato sqlite3.

Ho pensato di pubblicare il programma, con licenza GPL3, pensando che possa essere utile a qualcuno, comunque ho già cominciato a scrivere l’interfaccia grafica per accedere ed elaborare i dati (una specie di calcolatore di calorie) sperando che possa tra qualche tempo entrare a far parte del programma per la gestione e l’archiviazione delle ricette che ho intenzione di scrivere.

</p>

<p style="text-align: left;">#! /usr/bin/python
#-*- coding: utf-8 -*-
# Script per effetuare il parsing delle pagine dati INRAN e per
# salvare i dati in maniera ordinata in un database SQlite3
# Copyright (C) 2008  Alessandro De Noia <alessandro .denoia@gmail.com>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

import re, sqlite3, string
from BeautifulSoup import BeautifulSoup
from time import time
from urllib import urlopen

def NormalizeStr(FoodStr):
"""Restituisce la stringa senza il commento tra parentesi quadre e senza apici
Return a new string without the comment in the square brackets and without the apices  """
if string.find(FoodStr, "[") == -1:
NewFoodStr = FoodStr
else:
NewFoodStr = FoodStr[0:(string.find(FoodStr, "[")-1)]
return string.join(string.split(NewFoodStr,'\''),"\\''")

def NormalizeNum(DataNum):
"""Restituisce un numero float cambiando la virgola in punto o altrimenti cambia la stringa None nel valore NULL
Return a float number turning the comma into a dot or else change the string None into the value NULL"""
if string.find(DataNum, ",") != -1:
NewDataNum = round(float(string.join(string.split(DataNum,","),".")),2)
elif (DataNum == "None") or (DataNum == "tr") or (DataNum == " "):
NewDataNum = -1.00
else:
NewDataNum = round(float(DataNum),2)
return NewDataNum

def Database():
"""Crea, popola e riempie il database con i dati acquisiti
Create, populate and fill the database with the acquired data"""
data = ['']*22
rows = ('inran_id', 'pe', 'acqua', 'proteine', 'lipidi', 'carboidrati', 'amido', 'zucchero', 'fibra', 'energia_c', 'energia_j', 'sodio', 'potassio', 'ferro', 'calcio', 'fosforo', 'tiamina', 'riboflavina', 'niacina', 'vit_a', 'vit_c', 'vit_e')
categories = ('cereali', 'legumi', 'verdure', 'frutta', 'carni_fresche', 'carni_trasformate', 'fast_food', 'frattaglie', 'pesca', 'latte', 'formaggi', 'uova', 'olii', 'dolci', 'vari', 'alcooliche')
Nid = 0
conn = sqlite3.connect("inran")
cur = conn.cursor()
cur.execute("""CREATE table inran (id INTEGER PRIMARY KEY,
inran_id FLOAT,
categoria VARCHAR NOT NULL,
alimento VARCHAR NOT NULL,
pe FLOAT DEFAULT 100,
acqua FLOAT DEFAULT NULL,
proteine FLOAT DEFAULT NULL,
lipidi FLOAT DEFAULT NULL,
carboidrati FLOAT DEFAULT NULL,
amido FLOAT DEFAULT NULL,
zucchero FLOAT DEFAULT NULL,
fibra FLOAT DEFAULT NULL,
energia_c FLOAT DEFAULT NULL,
energia_j FLOAT DEFAULT NULL,
sodio FLOAT DEFAULT NULL,
potassio FLOAT DEFAULT NULL,
ferro FLOAT DEFAULT NULL,
calcio FLOAT DEFAULT NULL,
fosforo FLOAT DEFAULT NULL,
tiamina FLOAT DEFAULT NULL,
riboflavina FLOAT DEFAULT NULL,
niacina FLOAT DEFAULT NULL,
vit_a FLOAT DEFAULT NULL,
vit_c FLOAT DEFAULT NULL,
vit_e FLOAT DEFAULT NULL)""")
for category in categories:
try:
socket = urlopen('http://www.inran.it/servizi_cittadino/per_saperne_di_piu/tabelle_composizione_alimenti/composizione/'+category)
except:
print("Impossible to resolve the host, please check internet connection")
exit()
page = BeautifulSoup(socket.read())
socket.close()
food = page.findAll('td', {"class":re.compile("descrizione_[1-2]")})
FoodData = page.findAll('td', {"class":re.compile("dato_[1-2]")})
n = 0
for i in food:
StrSql = ("""INSERT INTO inran (id, categoria, alimento)
VALUES (%d,'%s','%s')""") % (Nid, category, NormalizeStr(i.string))
cur.execute(StrSql)
data = FoodData[(22*n):(22*(n+1))]
m = 0
for k in data:
StrSql2 = ("UPDATE inran SET %s=%f WHERE id=%d") % (rows[m], NormalizeNum(str(k.string)), Nid)
cur.execute(StrSql2)
m = m + 1
n= n + 1
Nid = Nid + 1
cur.close()
conn.commit()
conn.close()

time1 = time()
print("-------------------------------------------------------------")
print("Sto creando il database, attendere")
print("-------------------------------------------------------------")
Database()
time2 = time()
print("-------------------------------------------------------------")
print("Database creato in %f secondi") % (time2 - time1)
print("-------------------------------------------------------------")
<p style="text-align: left;">

Scaricate il file da qui e poi eseguitelo da un terminale semplicemente digitando (è necessario avere installato il modulo BeautifulSoup dai repository di Ubuntu):

$: python iran.py

Essendo scritto in python funziona su qualsiasi sistema operativo con python 2.5 e i relativi moduli installati.

Software libero:idee e prospettive

Si terrà domani alle 9.30 nell’aula 4 al palazzo delle aule alla facoltà di scienze MM.FF.NN il seminario:

Software libero:idee e prospettive

L’opensource nella pubblica amministrazione e nell’università

La WiFi nell’UNIBA su KDE

Verrà fatta anche una dimostrazione di configurazione della rete WiFi dell’università e sarà presentato un software per gestire le reti WiFi scritto da due studenti del politecnico per il desktop environment KDE4.