scripting

scp

Aggiungo qualche promemoria sull’utilizzo di scp (secure copy).

– Eseguire la copia di un file da host locale a host remoto:

$ scp nome_file utente@IP_ADDRESS_HOST_DESTINAZIONE://percorso/alla/dir/di/destinazione/

per copiare una intera directory aggiungere l’opzione “r” prima della sorgente dati, per esempio:

$ scp -r nome_directory utente@IP_ADDRESS_HOST_DESTINAZIONE://percorso/alla/dir/di/destinazione/

– Eseguire la copia di un file da host remoto a host locale:

$ scp utente@IP_ADDRESS_HOST_REMOTO://percorso/alla/dir/di/origine /percorso/alla/dir/di/destinazione/

linux | qualche tip, qualche trick…

rename

comando per rinominare uno o piu’ file; in particolare mi e’ tornato utile per rinominare una serie di immagini che presentavano alcune lettere maiuscuole, altre minuscole. Per riportare tutto a minuscolo:

$ rename ‘y/A-Z/a-z/’ *

In questo modo tutti i file presenti nella dir corrente vengono trattati e rinominati in lowercase.

Per rinominare una serie di file modificando soltanto una parte:

$ rename ‘s/stringa_vecchia/stringa_nuova/’ *

primo script in python | da gradi sessagesimali a gradi decimali

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

il primo “hello world” in python

A distanza di qualche mese mi sono riavvicinato alla programmazione (una espressione “grossa” per me) tentando di rifare un esperimento: convertire un angolo dal formato gradi primi secondi a decimale.

Riporto il codice python:

gradi = input(‘scrivi i gradi: ‘)
primi = input(‘scrivi i primi: ‘)
secondi = input(‘scrivi i secondi: ‘)
print “l’angolo in formato decimale e'”,float(gradi)+(((float(secondi)/60)+float(primi))/60)

[per evitare di dichiarare ogni input come float() si puo’ importare il modulo divisione; ecco il codice modificato:

from __future__ import division
gradi = input(‘scrivi i gradi: ‘)
primi = input(‘scrivi i primi: ‘)
secondi = input(‘scrivi i secondi: ‘)
print “l’angolo in formato decimale e'”,gradi+(((secondi/60)+primi)/60)

il risultato non cambia]

salvandolo in un file che potermmo chiamare dms2dd.py ed eseguendolo otterremo quanto richiesto:

$ python2.7 dms2dd.py
scrivi i gradi: 45
scrivi i primi: 5
scrivi i secondi: 5
l’angolo in formato decimale e’ 45.0847222222

il primo “Hello world” in C

Non sono un programmatore; non conosco nessun linguaggio di programmazione. Per questo, approfittando di una piccola necessita’ lavorativa, mi sono avvicinato al C.

Bazzicando in rete ho trovato alcuni “punti di partenza” molto ben fatti:

– introduzione alla programmazione in C;

– piccolo corso di programmazione in C;

E da qui ne e’ uscito un piccolo programmino per convertire le coordinate geografiche (lat/long) da DMS (Gradi Primi Secondi) a DD (Gradi decimali).

L’ho scritto usato l’editor “nano” (semplice quanto efficace editor che offre colorazione del testo ben fatta).

Una volta scritto il testo sottostante salvarlo con il nome di “primo_test.c” (i codici sorgente in C vengono contraddistinti dal suffisso .c).

#include <stdio.h>
float a,b,c,d;
main()
{
printf(“inserisci i gradi: \n”);
scanf(“%f”, &a);
printf(“inserisci i primi: \n”);
scanf(“%f”, &b);
printf(“inserisci i secondi: \n”);
scanf(“%f”, &c);
d=a+(((c/60)+b)/60);
printf(“l’angolo in formato decimale e’ %f \n”, d);
}

Una volta salvato il codice deve essere compilato. Per fare questo ho usato il compilatore “gcc” mediante la seguente sintassi:

$ gcc primo_test.c -o primo_test.out

Viene creato un file eseguibile chiamato primo_test.out (nel caso non avessimo indicato il nome del file di outptu, gcc avrebbe nominato il file “a.out”).

Il programma si lancia con il comando

$ ./primo_test.out

Vediamo il codice. All’inizio del testo viene indicata la libreria da caricare per eseguire le operazioni (#include <stdio.h>).

Poi si passa al processo. Stampa a console la richiesta di inserire i valore dei gradi dell’angolo da convertire; fatto questo cattura il valore inserito e lo memorizza nella prima variabile dichiarata (di tipo float). Poi chiede di inserire il valore del primi e memorizza il valore nella seconda variabile. Infine richiede i secondi e li memorizza nella terza variabile.

Fatto questo esegue l’operazione di conversione e propone in output il valore dell’angolo calcolato.

script per backup periodici di database postgresql/postgis

Una delle cose belle di Linux e’ che ti spinge a curiosare nel suo “mondo”; si scoprono cose davvero fantastiche per quanto semplici.

Per esempio: avevo necessita’ di eseguire un backup di alcuni database potgresql/postgis in maniera continua (su HD removibile HP RDX 320 GB)

Ho creato uno script per fare tutto cio’; in un secondo momento ho modificato il CRONTAB della macchina per fare in modo che questo script venga eseguito ad una certa ora del giorno.

Partiamo dall’inizio:

– con l’editor “nano” creiamo il file “backup.sh” nella directory “/usr/bin/”

– cd /usr/bin

– nano backup.sh

e lo compiliamo nel modo seguente:

#!/bin/bash

export PGPASSWORD=”mia_password_del_db” && pg_dump -h localhost -U user -c -d -R -v nome_database -n nome_schema > /percorso/dove/salvare/il/file.sql

L’istruzione “export PGPASSWORD=”mia_password_del_db” permette di dichiarare la password stessa senza doverla inserire ogni volta che lo script viene lanciato (questo renderebbe inutile un backup notturno in quanto il prompt si aspetterebbe l’immissione della pwd a mano).

Chiudiamo nano e salviamo il file. Rendiamolo eseguibile (da root):
# chmod +x /usr/bin/backup.sh

Modifichiamo il crontab per eseguirlo ad una certa ora del giorno:

@ crontab -e

e inseriamo le seguent righe:

00 04 * * * /usr/bin/backup.sh

In questo modo il backup viene lanciato ogni giorno alle 4 di mattina.

qgis | compilazione in Debian

Mi sono buttato nella compilazione di qgis.
Grazie alle dritte di Paolo Cavallini ho provato per la prima volta su Debian Lenny.

A distanza di qualche mese ho riprovato tutta la procedura di Debian Sid: le istruzioni qui riportate fanno riferimento a questa distribuzione.
Ad oggi (settembre 2011) i sorgenti di QGIS sono reperibili su github e non più su SVN. Pertanto la procedura riportata qualche mese fa (la tengo comunque per memoria e viene indicata in coda al post in grigetto) viene aggiornata.

Tutto quanto segue è spiegato benissimo in questa pagina wiki di QGIS. Unica differenza: il comando per il recupero dei sorgenti da git hub indicato “git clone git://github.com/qgis/Quantum-GIS.git” non funziona. Dopo qualche secondo compare un messaggio di time-out. Sostituendolo con il seguente “git clone https://github.com/qgis/Quantum-GIS.git” (come indicato qui:”http://www.qgis.org/wiki/Using_Git“) tutto funziona a dovere.

Riporto qui i passaggi importanti testati su Debian Sid (unstable).

– Preparazione dell’ambiente installando i pacchetti necessari via apt-get (o synaptic):

# apt-get install build-essential debhelper bison cmake doxygen flex graphviz grass-dev libexpat1-dev libfcgi-dev libgdal1-dev libgeos-dev libgsl0-dev libpq-dev libproj-dev libqt4-dev libqtwebkit-dev libqwt5-qt4-dev libspatialite-dev libsqlite3-dev pkg-config pyqt4-dev-tools python python-dev python-qt4 python-qt4-dev python-sip python-sip-dev txt2tags

– Creiamo le directory necessarie:

$ mkdir -p ${HOME}/dev/cpp

– poi ci spostiamo nella nuova directory “cpp”

cd ${HOME}/dev/cpp

– scarichiamo da github i sorgenti di QGIS con il comando:

$ git clone https://github.com/qgis/Quantum-GIS.git

Questo crea una nuova directory “Quantum-GIS” e vi scarica all’interno i sorgenti.

– Ci spostiamo all’interno:

$ cd Quantum-GIS

– e creiamo una nuova directory “build-master”; al suo interno lanceremo la compilazione:

$ mkdir build-master

– Entriamo

$ cd build-master

e lanciamo ccmake

$ ccmake .. -Wno-dev

il sistema preparerà l’ambiente per la compilazione fornendoci una serie di opzioni.

– abilitare i “global python bindings” schiacciando INVIO (la voce cambia da “OFF” a “ON”)
– dare “c” (sta per “configure”). A questo punto possono presentarsi dei messaggi di errore. Nel mio caso mi avvertiva della mancanza di alcune librerie (libgsl e altro…). Uscire con “e”, poi “q” (quit) e installare i pacchetti necessari (se abbiamo installato come da istruzioni sopra, non dovrebbero comunque esserci problemi).

– dare nuovamente il comando “c” e poi “g” (sta per “generate”). Dovrebbe tornare la console; questo indica che tutto è pronto per la compilazione.

– Impartiamo ora il make. Facendo tesoro di un post di Alessandro Furieri in cui riporta un trucchetto eccezionale per velocizzare il processo di make lanciamo il comando

$ make -j4

il suffisso “j4” indica a make di eseguire la compilazione in 4 thread paralleli. Il risultato è una compilazione molto più veloce che sottopone la CPU ad un carico costante del 100% ca.

– Infine installiamo (da root) con il classico:

# make install

—————————————————————————————————————-

In alternativa alla compilazione diretta è possibile crearsi i pacchetti “.deb”. Per fare questo risaliamo di una posizione con:

$ cd ..

e poi diamo il comando (come root):

# dpkg-buildpackage -us -uc -b

Questo creerà tutti i pacchetti necessari nella directory “Quantum-GIS”.

Risaliamo quindi di una posizione e installiamo tutti i pacchetti con:

# dpkg -i *.deb

Durante l’installazione è comparso un messaggio d’errore: ” Si sono verificati degli errori nell’eleborazione: libqgis-dev”. Verificando le dipendenze di questo pacchetto mi sono accorto della mancanza di “qt4-designer”. Installato questo tutto è andato a posto.

<inizio vecchia procedura>

– Creare una directory di lavoro (es: compila_qgis):
$ mkdir compila_qgis
Spostarsi dentro la directory appena creata:
$ cd compila_qgis
E’ necessario avere installato alcuni pacchetti. Li installiamo:
# apt-get install subversion cmake flex bison libgsl0-dev libboost-python-dev python-eggtrayicon python-foomatic python-gnome2 python-gps python-gtkhtml2 python-gtkmozembed python-qt4-dev python-reportlab python-svn grass-dev libqt4-gui sharutils sip4 libqwt5-qt4-dev libqt4-core pyqt4-dev-tools qt4-qmake libqt4-dev libgdal-dev libncurses5-dev dpkg-dev debhelper libexpat1-dev libxext-devlibfontconfig1-dev proj libxi-dev libxrandr-dev libxrender-dev libice-dev libsm-devcmake-curses-gui

Molto probabilmente non tutti sono necessari ma averli non fa male 🙂
Poi scarichiamo l’svn con:
$ svn co https://svn.osgeo.org/qgis/trunk/qgis qgis_unstable
– creiamo le directory necessarie
$ mkdir qgis_unstable/build/
– ci spostiamo dentro:
$ cd qgis_unstable/build/
– diventare root e poi:
# ccmake .. -Wno-dev
– abilitare i “global python bindings” schiacciando INVIO (la voce cambia da “OFF” a “ON”)
– dare “c” (sta per “configure”). A questo punto possono presentarsi dei messaggi di errore. Nel mio caso mi avvertiva della mancanza di alcune librerie (libgsl e altro…). Uscire con “e”, poi “q” (quit) e installare i pacchetti necessari (se abbiamo installato come da istruzioni sopra, non dovrebbero cmq esserci problemi).
– ritornare in cmake con
# ccmake .. -Wno-dev
In questo modo si apre (sempre nella console) un pannello per impartire comandi di cmake (il compilatore).
– dare ancora il comando “c”, poi “g”: in questo modo si generano gli script necessari. Il pannello di cmake si chiude da se e ci ritroviamo con la console.
A questo punto risalire alla directory superiore con:
# cd ..
– lanciare il comando per la creazione dei .deb
# dpkg-buildpackage -us -uc -b
– vengono visualizzati una serie di log di comandi (nel mio caso, ad un certo punto si e’ fermato perche’ non trovava “grass-dev” e “libqt4-dev”; installato questi e re-impartito il comando di creazione dei pacchetti)
– si risale nuovamente di una posizione:
# cd ..
– si installano i .deb generati:
# dpkg -i *.deb

Se tutto e’ andato a buon fine ritorna la console con #.
Lanciare qgis:
$ qgis [INVIO]

Per le successive compilazioni basta impartire il comando:
$ svn up https://svn.osgeo.org/qgis/trunk/qgis qgis_unstable
in modo da aggiornare la versione SVN scaricata.
Poi continuare nuovamente con i comandi riportati sopra.
Può succedere che durante la fase di creazione del pacchetti “# dpkg-buildpackage -us -uc -b” venga riportato un errore di conflitti con alcuni pacchetti (nel mio caso qgis-dev e libqgis-dev). Rimuovere il pacchetto libqgis1.2.0-dev. Eventualmente (se non si conosce il nome del pacchetto) può essere utile usare il comando:
# dpkg –list | grep qgis
In questo modo troviamo tutti i pacchetti relativi a qgis e possiamo facillmente individuare quelli “scomodi”. Per rimuoverli (compresi i file di configurazione) impartire:

# dpkg –purge nome_pacchetto (p.e.: # dpkg –purge libqgis1.2.0-dev)

Quindi re-impartire il comando di creazione dei pacchetti.

</fine vecchia procedura>

Conversione di uno SHP da coordinate WGS84 a Gauss-Boaga Fuso Ovest (GB Fuso Ovest -> WGS84 nel commento)

Questo post è l’evoluzione di quello relativo a “GPX | magie con gpsbabel”. In quel post è descritta una procedura per convertire un file GPX (trk) in SHP (wpt) avente una tabella attributi popolata anche con il TIMESTAMP. Questo per consentire di “rincorrere” il percorso effettuato in base all’ora di interrogazione.

Tuttavia questa conversione di formato produce in output dati geografici in un sistema di coordinate universale per i GPS: il WGS84 (codice EPSG:4326).

E’ utile poter convertire tali dati anche in altri sistemi di riferimento; in particolare, lavorando in Veneto, è basilare convertire tutto in Gauss_boaga Fuso Ovest (codice EPSG:3003) quale sistema di riferimento adottato dalla Regione Veneto per la CTRN (Carta Tecnica Regionale Numerica). Per fare questo ci viene in aiuto un altro magico tool: ogr2ogr. E’ uno strumento che consente la conversione di svariati formati vettoriali, compresa la possibilità di convertirli da un sistema di riferimento ad un altro.

La sintassi del comando è di questo tipo:

$ ogr2ogr output.shp input.shp -s_srs EPSG:4326 -t_srs EPSG:3003

In questo esempio si effettua la conversione di un file SHP da WGS84 a Gauss-Boaga Fuso Ovest.

Ma il risultato che si ottiene non è buono: caricando lo SHP generato (es tramite Qgis) e sovrapponendolo alla CTRN si nota uno scostamento rigido verso nord-ovest.

Nell’immagine seguente si può notare lo scostamento rispetto alla reale posizione della strada.

traccia riproiettata senza parametri "+towgs84"

traccia convertita senza parametri "+towgs84"

Questo errore si può rimediare inserendo i parametri comprensivi di “+towgs84” in luogo di “-t_srs”. Pertanto il comando per ottenere una riproiezione corretta (ci sono ancora errori, ma notevolmente ridotti) è il seguente:

$ ogr2ogr gb_$nome_ref.shp $nome_ref.shp -s_srs EPSG:4326 -t_srs ‘+proj=tmerc +ellps=intl +lat_0=0 +lon_0=9 +k=0.999600 +x_0=1500000 +y_0=0 +units=m +towgs84=-104.1,-49.1,-9.9,0.971,-2.917,0.714,-11.68’

Il risultato è questo:

traccia convertita con parametri "+towgs84"

Per continuare con il post precedente sopra citato ho aggiornato lo script in Perl già pubblicato. In sostanza lo script fa 4 cose:

– scarica i dati dal GPS (nel caso specifico un i-blue 747);

– converte le track (trk) in waypoint (wpt) per poter memorizzare il TIMESTAMP di ogni punto;

– converte il nuovo GPX in SHP (con tabella attribuiti ben popolata);

– converte lo SHP generato dal sistema WGS84 a Gauss-Boaga Fuso Ovest

Questo lo script integrale: script_trk2wpt

Se trovate imprecisioni commentate!

GPX | magie con gpsbabel :-)

GPX è un formato di interscambio dati per dispositivi GPS. Sostanzialmenete è un file XML. Al suo interno vengono memorizzate, oltre alle coordinate X,Y e Z, anche altre informazioni quali DATE e TIMESTAMP. E proprio quest’ultimo dato è l’oggetto di questo post. Tutto è nato dalla necessità di salvare i dati recuperati via GPS in uno SHP (shape file: formato dati standard in ambito GIS) in modo da poter localizzare (mediante query) la mia posizione ad una determinata ora. Caricando un file GPX in Qgis vengono visualizzate tracce (trk), waypoint (wpt) e rotte (rte). Durante l’acquisizione della traccia vengono “taggati” n punti ogni TOT secondi (ho impostato la rilevazione della posizione in base al tempo). La traccia visualizzata diventa un record unico e ad essa sono abbinati una serie di dati. Ma in questo modo non riesco a risalire alla mia posizione; i dati sono riferiti al tracciato nella sua interezza. Esiste un tool davvero eccezionale: GPSBABEL. Consente una buona serie di “magie” per convertire dati GPX. In particolare è possibile convertire una traccia in una serie di wp. In questo modo ad ogni punto viene associato anche il momento in ci è stato rilevato. In seconda battuta si può trasformare il nuovo GPX con i wp in SHP mediante OGR2OGR o GPX2SHP. vediamo i passi necessari:

– trasformazione delle tracce in waypoint mediante gpsbabel:
$ gpsbabel -i gpx -f nome_traccia.gpx -x transform,wpt=trk -o gpx -F nome_wp.gpx

– conversione del GPX in SHp mediante gpx2shp:
$ gpx2shp -w -o nome_wp.shp nome_wp.gpx

Visto che questo lavoro dovrebbe processare una serie di tracce recuperate in tempi diversi da persone diverse ho predisposto (una vera operazione di hackeraggio artigianale vista la mia bassissima esperienza di programmazione) un piccolo e semplice script in Perl. Lo script ha come requirements la presenza di perl, gpsbabel e gpx2shp e deve essere eseguito all’interno della directory contenente i GPX da processare.
Lo script in formato PDF: gpx_trk2wpt_gpx2shp. Copiare il testo e incollarlo in un nuovo file. Dare un nome al file (Es: converter_gpx_shp.pl) con estesnione .pl e lanciarlo con:
$ perl converter_gpx_shp.pl
All’avvio viene chiesto il nome del GPX da elaborare (omettendo l’estensione .GPX) ed il nome da dare al file generato. A fine operazione vengono generati un nuovo GPX contente i WP delle tracce ed uno SHP con i WP stessi.
Questo SHP può essere caricato in Qgis per le opportune elaborazioni.

PHP | Gestione di “submit” multipli in un singolo form

Con questo metodo è possibile gestire gli eventi di un form in base a scelte multiple consentite all’utente. Il codice PHP trattato esegue un codice diverso a seconda del valore impostato in un campo “input” o “select” o ….
Costruiamo il form per la scelta, mediante <select></select>, di valori alternativi. In base al valore scelto viene aperto un file diverso mediante il codice scritto nel file “script.php”.

<html>

<form action=”script.php” method=”POST”>
<b>scegli un’opzione:</b>

<p class=”pulsante”>
<select name=”nome_option”>
<option>option01</option>
<option>option02</option>
<option>option03</option>
<option>option04</option>
</select>

</form>

</html>

E questo è lo “script.php”:

<?php
switch ($_POST[‘nome_option’]) {

case “option01”:
readfile (“file01.php”);
break;

case “option02“:
readfile (“file02.php”);
break;

case “option03”:
readfile (“file03.php”);
break;

case “option04”:
readfile (“file04.php”);
break;

}

Viene utilizzato il costrutto “switch”, “case”…Si impiega quando è necessario effettuare test multipli su epressioni singole. Nel caso del nostro script viene aperto (con il costrutto “readfile”) un file diverso a seconda del valore selezionato nel form iniziale.