Un piccolo e breve post su una funzione di Postgis molto utile per invertire l’ordine di digitalizzazione dei vertici di un oggetto. Nel caso specifico si fa riferimento ad oggetti lineari. La funzione è (brevemente) documentata qui. Ed ecco un esempio pratico per invertire il senso di 3 linee identificate mediante il loro gid:
#= UPDATE nome_tabella_linee SET the_geom = ST_Reverse(the_geom) WHERE gid IN (8,128,46);
I valori dei “gid” indicati sono puramente esemplificativi.
Con questo post volevo tenere traccia della procedura di aggiornamento e migrazione dati da Postgresql 8.3 e Postgis 1.3.3 a Posgresql 8.4.11 e Postgis1.5.1.
Ho seguito questa utilissima pagina wiki
Sul nostro server “girano” attualmente Postgresql 8.3 e Postgis 1.3.3.
1- Facciamo dapprima il backup dei database presenti (il comando va lanciato per ogni db presente nel cluster).
$ PGUSER=postgres pg_dump -Fc nome_db > /percorso/alla/dir/di/dump/nome_db.dmp
NB: pg_dump con l’opzione -Fc crea un archivio compresso (un tar compresso con gzip, ovvero un tar.gz).
Nel caso si trattasse di db non spaziale e’ sufficiente dare:
$ PGUSER=postgres pg_dump -c nome_db > /percorso/alla/dir/di/dump/nome_db.sql
2- Stoppiamo Postgresql-8.3 (come root):
# /etc/init.d/postgresql stop 8.3
3- Installiamo Postgresql-8.4 e Postgis-1.5
# aptitude install postgresql-8.4 postgresql-8.4-postgis
A questo punto (non ricordo purtroppo tutte le fasi che ho percorso) al comando di stop de nuovo postgresql-8-4 compariva un errore. Ho provato a reinstallarlo ma a questo punto ottengo:
# Error: move_conffile: required configuration file /var/lib/postgresql/8.4/main/postgresql.conf does not exists.
Decido allora di reinstallare tutto ma succede il fattaccio. Non si riesce piu’ a lanciare postgresql-8-3. Il messaggio d’errore diceva che non esiste piu’ la directory “/var/lib/postgresql/8.3/main” panic…..praticamente mi e’ sparito tutto il cluster di postgresql-8.3, fumato!
Ok, pero’ i backup li ho e decido di fare un purge profondo prima di ripartire. Cerco tutti i pacchetti relativi a Postgresql.
# dpkg -l | grep postg
e rimuovo tutto con:
# aptitude purge postgresql-8.3 postgresq-8.4 postgresql-client-8.3 postgresql-client-8.4 postgresql-client-common postgresql-common postgresql
Rimuovo anche tutte le directory di sistema:
# rm -r /etc/postgresql/
# rm -r /etc/postgresql-common/
# rm -r /var/lib/postgresql/
poi togliamo manualmente l’utente “postgres” dal file “/etc/passwd” (mediante “# nano /etc/passwd” e modificando il file eliminado la riga di interesse).
Quindi reinstallo tutto con:
# aptitude install postgresql-8.4 postgresql-8.4-postgis (che si tira dietro anche tutte le dipendenze del caso)
A questo punto possiamo recuperare i dump fatti. Per fare questo ci viene in aiuto uno script in perl che si installa con postgis-1.5 (new_postgis_restore.pl).
Prima si devono ricreare i database vuoti (con lo stesso nome di quello di partenza). Essendo tutti db spaziali creiamo dapprima un template spaziale che chiamiamo “template_gis” e lo useremo poi per creare ogni db.
Come utente postgres creiamo anche gli utenti dei db stessi:
$ su
# su postgres
(come utente postgres) # psql template1; (si entra in un db qualsiasi per creare gli utenti)
=# CREATE USER nome_utente WITH PASSWORD ‘secret’ CREATEDB CREATEUSER;
Creo il nuovo database che diventaera’ il template (sempre come utente postgres):
=# CREATE DATABASE template_gis template=template0;
Usciamo dal db (<CTRL>d) e (sempre come utente postgres) importiamo in esso le funzioni spaziali:
# psql -f /usr/share/postgresql/8.4/contrib/postgis-1.5/postgis.sql -d template_gis
poi
# psql -d template_gis -f /usr/share/postgresql/8.4/contrib/postgis-1.5/spatial_ref_sys.sql
A questo punto rientriamo in template1:
# psql template1;
e facciamo in modo che il nuovo db sia un template usabile in futuro:
# UPDATE pg_database SET datistemplate=’t’ WHERE datname=’template_gis’;
ok, ora possiamo creare tutti i nostri db in base a questo template.
# CREATE DATABASE nome_db template=template_gis OWNER nome_utente; (questo va fattoper ogni db)
Quindi popoliamo i db con lo script perl citato prima (come utente normale):
$ /usr/share/postgresql/8.4/utils/new_postgis_restore.pl /percorso/alla/dir/di/dump/nome_db.dmp | psql nome_db
Vedremo scorrere sul terminale una serie di istruzioni (il db si sta popolando). Fatto.
Alla fine (nel mio caso) ricordarsi di modificare i file “/etc/postgresql/8.4/main/postgresql.conf” e “/etc/postgresql/8.4/main/pg_hba.conf”.
Per il primo decommentare la riga relativa a “listen_addresses” e inserire l’asterisco al posto di “localhost” come riportato:
#——————————————————————————
# CONNECTIONS AND AUTHENTICATION
#——————————————————————————
# – Connection Settings –
listen_addresses = ‘*’ # what IP address(es) to listen on;
………………
Per il secondo (nella parte finale del file):
# Database administrative login by UNIX sockets
local all postgres ident
# TYPE DATABASE USER CIDR-ADDRESS METHOD
# “local” is for Unix domain socket connections only
local all all trust
# IPv4 local connections:
host all all 127.0.0.1/32 trust
host all all 0.0.0.0/0 trust
# IPv6 local connections:
host all all ::1/128 trust
altrimenti non sono consentiti connessioni da altri client (nel primo file) e l’esecuzione di pg_dumpall (nel secondo file)
Pubblico il mio primo timido script “operativo ” in python. E’ frutto di un misto tra studio e tentativi vari spulciando tutorial in rete, un piccolo pocket libro e il famoso “diveintopython” :-).
Il lavoro che presento è l’evoluzione del piccolo script che, attendendo gli input dell’utente, converte i gradi, primi e secondi di un angolo in formato sessagesimale (una coordinata geografica in lat-lon per esempio) in formaro decimale (molto utile per l’elaborazione in molti programmi GIS).
In questo secondo step invece viene letto un file in formato .CSV contenente gli angoli nel formato gradi, primi, secondi (con la virgola come separatore) e viene generato un nuovo file (.CSV) con gli angoli convertiti nella forma decomale. Ecco lo script:
========================
from __future__ import division
angoli= open( “/home/sit/python/angoli.txt”, “r” ) # apre in lettura il file che contiene gli angoli da elaborare
angoli_trasformati=open(“/home/sit/python/angoli_trasformati.txt”, “w”) # genera un nuovo file che conterra’ i risultati
for angolo in angoli:
try:
g, p, s = angolo.strip().split( “,” ) # crea una tupla eliminando eventuali spazi tra valori e separandoli (i valori) con una virgola “,”
res = float(g), float(p), float(s), (float(g)+(((float(s)/60)+float(p))/60)) # calcola il valore dell’angolo in formato decimale
print res
print>>angoli_trasformati, res # restituisce l’output sul file creato in precedenza
except ValueError:
pass
angoli.close() # chiude lo stat sul file aperto
angoli_trasformati.close() # chiude lo stat sul file generato
========================
ogni commento e’ benvenuto
Lavorando con Postgresql|Postgis mi capita spesso di avere delle tavole come viste “View” ottenute dal join di una tabella geomerica e di una tabella non-geometrica. Esempio: la tabella geometrica contiene poligoni (edifici) con un campo chiave (es= scheda); la tabella alfanumerica contiene tutti i dati relativi a quegli edifici + un campo chiave “scheda” come la prima.
Questo perché, in un lavoro svolto, un utente si occupava di gestire la parte geometrica (mediante QGIS) mentre un altro utente caricava i dati alfanumerici relativi ad un rilievo di edifici mediante interfaccia web (via PHP).
In un secondo momento quindi è stata creata una join fra le due tabelle in modo da generare tavole tematiche sulle condizioni e sull’uso di quegli edifici.
Ecco la View creata (siano “schede” e “schede_nogeom” rispettivamente la tabella geometrica e non-geometrica)
=> CREATE VIEW schede_cartogr AS SELECT scheda_nogeom.grado, scheda_nogeom.altezza, scheda_nogeom.volume, scheda_nogeom.piani, scheda_nogeom.note, scheda_nogeom.stcontetto, scheda_nogeom.punttetto, scheda_nogeom.stconprosp, scheda_nogeom.puntprosp, scheda_nogeom.stconserr, scheda_nogeom.puntserr, scheda_nogeom.stconsolai, scheda_nogeom.puntsolai, scheda_nogeom.stconmurat, scheda_nogeom.stcompl, scheda_nogeom.puntcompl, scheda_nogeom.d_uso_pint, scheda_nogeom.d_uso_pt, scheda_nogeom.d_uso_p1, scheda_nogeom.d_uso_p2, scheda_nogeom.d_uso_p3, scheda_nogeom.d_uso_p4, scheda_nogeom.d_uso_p5, scheda_nogeom.d_uso_compl, scheda_nogeom.d_uso_progetto, scheda_nogeom.d_uso_comp_grafica, scheda_nogeom.essenze_arboree, scheda_nogeom.emerg_arch, scheda_nogeom.h_pint, scheda_nogeom.h_pt, scheda_nogeom.h_p1, scheda_nogeom.h_p2, scheda_nogeom.h_p3, scheda_nogeom.h_p4, scheda_nogeom.h_p5, scheda_nogeom.vol_pint, scheda_nogeom.vol_pt, scheda_nogeom.vol_p1, scheda_nogeom.vol_p2, scheda_nogeom.vol_p3, scheda_nogeom.vol_p4, scheda_nogeom.vol_p5, scheda.area_gis, scheda_nogeom.foto1, scheda_nogeom.estratto_cartografico, scheda_nogeom.vol_residenza, scheda_nogeom.vol_comm_dir, scheda_nogeom.vol_artigianale, scheda_nogeom.vol_pubblico, scheda_nogeom.vol_misto, scheda_nogeom.puntmurat, scheda_nogeom.d_uso_vigente, scheda.gid, scheda.the_geom, scheda.scheda FROM scheda JOIN scheda_nogeom ON scheda.scheda::text = scheda_nogeom.scheda::text;
– Caricando questa vista in QGIS riusciamo quindi a consultare geometrie e tutti i valori colelgati. Ma se ad un certo punto voglio modificare un valore o alcuni valori della tabella? Abilitando l’editing sul layer “schede_cartogr” vediamo che possiamo modificare i valori ma al momento del salvataggio veniamo avvisati che non è possibile. Ci viene allora in aiuto la creazione di un RULE con istruzione “DO INSTEAD” in Postgresql . In sostanza si tratta di una regola che consente di modificare la (o le) tabelle origine agendo sulla vista.
In generale la sintassi è la seguente:
>= CREATE RULE nome_rule_da_creare AS ON UPDATE TO nome_della_view DO INSTEAD UPDATE nome_tabella_origine SET nome_campo=NEW.nome_campo WHERE campo_chiave=NEW.campo_chiave;
Ecco la definizione del RULE che ho usato:
=>CREATE RULE update_grado_schede_cartogr AS ON UPDATE TO schede_cartogr DO INSTEAD UPDATE scheda_nogeom SET grado=NEW.grado WHERE scheda=NEW.scheda;
D’ora in avanti possiamo modificare da QGIS il valore del campo “grado“; verrà aggiornato di conseguenza il valore della tabella originale.
Se durante una sessione di lavoro con QGIS vogliamo eseguire un “copia/incolla” di dati da una tabella ad un foglio di calcolo LibreOffice puo’ succedere che i dati “incollati” presentino alcuni problemi. In particolare i dati numerici decimali (aree di oggetti poligonali per esempio) vengono mantenuti come “testo” e non numero con tutte le conseguenze negative del caso: se vogliamo fare una somma di valori ottenimao un errore.
Come fare per ovviare a tutto cio’?
Andiamo per punti:
– dalla sessione QGIS apriamo la tabella attributi del layer interessato, selezioniamo tutte o parte delle righe che ci interessano e clicchiamo sul pulsante “copia le righe selezionate nel blocco appunti” che si trova in basso a sinistra della tabella.
– apriamo una sessione di LibreOffice Calc e andiamo su “modifica > incolla” oppure “CTRL+V“;
– ci si presenta la finestra di impostazione dei dati di import che si chiama “Importazione testo” (lo vediamo scritto in alto sulla barra della finestra di popup stessa);
– su “Tipo di carattere” lasciamo “Unicode” come da default e poi scegliamo il simbolo di delimitazione (dovrebbe andare bene la “tabulazione” come proposto); a questo punto ci troviamo i nostri dati nel foglio di calcolo;
– Se schiacciamo contemporaneqmente “CTRL+F8” vedremo alcuni valori diventare blu. Sono i valori numerici. Il resto rimane nero (il testo). In verde eventuali valori calcolati da altri campi (ma essendo dati appena importati non avremo alcun campo di colore verde).
– Nel mio caso ho una colonna che riporta l’area di elementi poligonali e, ahimè, i suoi valori non diventano blu ma rimangono neri. Significa che sono dati importati come testo. Se infatti selezioniamo le celle interessate, tasdo dx e “Formatta celle…” vedremo che il tipo di dato è impostato su “testo”.
– Modifichiamo questa impostazione impostando su “categoria=numero” e “formato=standard”; in questo modo, tornando sul foglio di calcolo e selezionando una delle celle interessate vedremo che il valore indicato nella “riga di digitazione” presenta un’apostrofo “‘“all’inizio. Questo significa che la cella dovrebbe contenere numeri ma il valore inserito è un testo. Nel mio caso trovo: ‘1011.15.
– Il problema sta nel fatto che il nostro separatore dei decimali è la virgola “,” mentre i dati incollati hanno importato come separatore il punto “.”.
– Basta fare un “trova e sostituisci” (CTRL+ALT+F) sulle celle interessate e sostituire il punto con una virgola.
– A questo punto vedremo automagicamente comparire i nostri valori in blu (ergo sono diventati numeri a tutti gli effetti).
Si terrà a Foggia il quarto GFOSS-DAY. Dopo le edizioni di Pontedera, Bolzano e Foligno quest’anno si sposta in Puglia. L’evento interesserà le giornate del 24 e 25 novembre e sarà caratterizzato da un nutrito calendario di eventi.
Per maggiori dettagli e specifiche teniamo d’occhio il sito dell’associazione http://gfoss.it in particolare la pagina http://gfoss.it/drupal/gfossday2011
Premetto come per ogni post su questo blog che quanto scrivo è frutto di tentativi e ricerche per risolvere un problema pratico che di volta in volta mi si presenta. Non è detto quindi che sia il modo migliore ed il più elegante; ogni feedback e/o consiglio è pertanto graditissimo.
Parto dall’inizio: dispongo di un grafo stradale (stradario comunale) archiviato in db Postgresql con estensione spaziale Postgis. La tabella contenente gli archi stradali si chiama “grafo_new”; in essa ogni arco di strada è spezzato all’intersezione con altri tratti. Questo comporta che una strada denomimata “Via Roma” sia composta da tanti archi. Inoltre il db contiene una griglia regolare di passo quadrato che identifica i quadranti del territorio comunale. Il problema da risolvere è: “Come faccio ad ottenere un elenco delle strade (in ordine alfabetico) che indichi anche il quadrante o i quadrantiall’interno dei quali la strada ricade”. Mi ricorda moltissimo il funzionamento della battaglia navale quando per colpire una nave avversaria di indicavano le coordinate: A7: acqua; B5: colpito; B6: colpito e affondato.
Un po’ come fa l’ottimo servizio maposmatic (http://www.maposmatic.org)
Ecco i passaggi che ho seguito:
1. creazione di una view in postgres che aggrega tutti i tratti di via con lo stesso nome:
#= CREATE VIEW view_grafo_union AS SELECT nome, ele_desc, ele_tipo, gid, ST_Multi(ST_Union(f.the_geom)) AS the_geom FROM grafo_new AS f GROUP BY nome ORDER BY nome;
2.creazione di una seconda view di intersezione spaziale tra il grafo e la griglia di quadranti:
#= CREATE VIEW view_grafo_union_quadrante AS SELECT ST_Intersection(r.the-geom, m.the_geom) AS intersection_geom, m.codice, r.nome FROM view_grafo_union AS r, quadrante_stradario AS m WHERE ST_Intersects(r.the_geom, m.the_geom);
3. Creazione di una query “array_to_string” che fornisca l’elenco di tutti i quadranti di instersezione per ogni tratto di strada:
#= SELECT DISTINCT a.nome, array_to_string(array(SELECT codice FROM view_grafo_union_quadrante AS b WHERE b.nome = a.nome),’,’) FROM view_grafo_union_quadrante AS a ORDER BY nome;
Per salvare il risultato dell’ultima query su un file basta impartire prima della query il seguente comando:
#= \o /percorso/al/file/di/output.csv
Il CSV potrà poi essere aperto e gestito con Calc o altro editor di testo.
To be continued con snapshot e altri dettagli….
Gli organizzatori dell’Ubuntu-party che si è svolto a Schio (Vicenza) lo scorso 30 aprile e 1 maggio hanno pubblicato su Vimeo i video dei talk.
Tra i tanti c’è anche il mio soporifero intervento su “Openstreetmap – La mappa del mondo creata dal basso”; se avete difficoltà a dormire e cercate un’alternativa alla conta delle pecore andate qui :-), sarò lieto di conciliarvi…
Buona notte.
Il papà di SpatiaLite, Alessandro Furieri, ha lanciato un altro ottimo tool: OpenLite. Si tratta di uno strumento leggerissimo e semplice per migrare database (interi o in parte) tra SpatiaLite, PostGIS e MySQL.
E’ disponibile in forma sorgente oppure binaria per Windows ed è accompagnato da una semplice ma esaustiva guida che si trova alla stessa pagina del progetto.
Ho provato ad installarlo dai sorgenti su Ubuntu 10.10. Ecco una sisntesi dei passaggi e delle prove fatte:
– scaricare i sorgenti da qui;
– scompattare tutto in una directory di lavoro; nel mio caso in “/home/sit/src/openlite-0.0.1”
– ci sono dipendenze da soddisfare: libspatialite e wxWidgets. Le installiamo via sudo apt-get install nome_pacchetti o via synaptic
– da riga di comando si accede alla directory interessata:
cd /home/sit/src/openlite-0.0.1
– lanciare in sequenza i tre canonici comandi:
./configure
make
sudo make install-strip
– a questo punto il programma è installato. Lo lanciamo da riga di comando con:
sit@dell1530:~$ openlite
– si presenta così:
la semplicità dello strumento si nota subito
– è necessario stabilire prima di tutto una connessione ad un db SQLite. Se ne esiste già uno colleghiamoci cliccando sul pulsante in alto a sx “Connecting an existing SQLite DB” e cerchiamo il DB interessato. In alternativa possiamo creare un DB nuovo cliccando sul secondo pulsante da sx “Creating a New (empty) SQLite DB”.
– in seconda battuta connettiamoci ad un atro DB. Nel mio caso ho provato con un DB PostGIS (PostgreSQL). Cliccare sull’icona con freccia azzurra e contenitore magenta “Connecting to PostgreSQL/PostGIS DBMS”. La prima volta che si tenta di connettersi ad un DB PostgreSQL viene chiedo di individuare la libreria necessaria. Nel nostro caso si tratta di “/usr/lib/libpq.so.5.2“. Questa impostazione viene salvata permanentemente ed ogni connessione successiva a DB PostgreSQ/PostGIS cercherà questa libreria. Nel caso si indicasse la libreria sbagliata viene restituito il messaggio “No PostgreSQL Client Library available … sorry
Connection impossible”. Per “sbloccare” la situazione ed impostare il percorso corretto alla libreria ci sono due alternative:
– alternativa 1 – brutale ma efficade:
– andare nella home directory
– lanciare il comando: ls -la
– dovremmo trovare un file nascosto chiamatto “.OpenLite” (è il file in cui vengono salvate le impostazioni permanenti)
– cancellare il file e ripartire.
– alternativa 2 – piu’ soft (ma non testata):
– andare nella home directory e aprire il file nascosto .OpenLite con: $ nano .OpenLite
– modificare la riga “PostgisLibraryName=libpq.so.5.2” indicando la libreria corretta.
– rilanciare openlite e ripartire.
Una volta individuata la libreria compare un popup per l’inserimento del percorso al DB e delle credenziali di accesso.
Connessione a DB PostgreSQL/PostGIS
Nella parte dx del pannello vengono elencate tutte le tabelle presenti del DB PostgreSQL. Selezionare con click sx la tabella che si vuole trasferire al DB SQLite e poi click dx. Compare un menù contenstuale: scegliere la voce “Select for data transfer”. Poi click dx sullo schema che contiene la tabella in questione (nel nostro caso “public“) altrimenti non è possibile avviare il tarsferimento. Fatto questo verrà abilitato un nuovo pulsante “Start data transfer” che si trova a sx del pulsante “About…”.
– Click sul pulsante indicato.
– Fatto: in questo modo avviene il trasferimento della tabella in questione al DB SQLite che comparirà dopo qualche secondo (a seconda delle dimensioni) nella parte sx del pannello.
La tabella "areacirc" è stata trasferita con successo
La definizione che capeggia nella home page del progetto è:
Ho sentito parlare per la prima volta di Ushahidi nel 2010 (inizio) quando Napo mi ha girato un link a riguardo.
Mi sono subito cimentato per installarlo ma per mancanza di tempo non ho avuto modo di arrivare alla fine e di testarlo.
Per ora inserisco questo video (tratto dal sito stesso del progetto)
ma appena riesco a cimentarmi meglio vorrei riportare un resoconto.
Nel frattempo ho provato la versione crowdmap che consente di realizzare da subito un sito proprio confezionato con una applicazione dimostrativa delle funzionalità dei Ushahidi. Tostissimo! Qui il test che ho fatto.
map freely 