File GPX | modificare il tag “Time”

Lavorando con il plugin “Qgis2leaflet” che consente la visualizzazione animata di un percorso GPX e’ necessario che venga popolato il tag (campo) “Time”. In genere se il file GPX deriva da un rilievo non ci sono problemi; il campo e’ correttamente popolato. Se deriva invece da un sistema di routing che consente l’esportazion in GPX o da una conversione in formato GPX da altro vettoriale (Es. SHP, Postgis,…), è necessario popolare questo valore altrimenti vuoto.

Per farlo ci viene in aiuto “gpsbabel” utilizzando la seguente sintassi:

$ gpsbabel -i gpx -f nome_file_gpx_in_entrata -x track,faketime=f20100705200000+10 -o gpx -F nome_file_gpx_in_uscita.gpx

In questo caso viene inserito un incremento di 10″ (10 secondi) tra un punto e l’altro (utile per il “motore” di visualizzazione animata di leaflet)

Ocitysmap | Creare mappe con Vie indicizzate

Ho provato a replicare in locale l’ottimo servizio offerto da maposmatic.org (un’applicazione per generare porzioni di mappa stampabili come file PDF, PNG, SVG,…. comprendente l’elenco dei nomi delle vie indicizzate in una griglia).

Ho seguito le istruzioni di installazione riportate nel pacchetto ocitysmap alle quali pero’ ho dovuto apportare alcune modifiche (la guida fa riferimento ad una installazione eseguita su ubuntu 14.04, mentre io ho provato su Debian testing ad oggi – ottobre 2016).

Per comodità operativa (potrebbe non essere il metodo migliore) e per dare chiarezza di lettura ai passaggi da eseguire ho strutturato l’ambiente di lavoro in questo modo:

– posizionandosi nella home dell’utente ho creato una directory in cui salvare i sorgenti chiamata “src”

$ mkdir src

– sempre all’interno della home ho creato un’altra directory chiamata “osm_data” al cui interno salveremo i dati scaricati dal server OSM e che saranno importati successivamente nel db PostGIS

$ mkdir osm_data

 

Ed ecco il procedimento globale:

1 Installazione di PostgreSQL e PostGIS

# apt-get install postgresql postgresql-contrib postgresql-9.4-postgis-2.2 (PostgreSQL 9.4.5)

2 Creazione di un nuovo utente di PostgreSQL

diventare root:

$ su

diventare superuser postgres:

# su postgres

Creare il nuovo utente di PostgreSQL:

# createuser -P -S -D -R maposmatic

(chiamiamo “maposmatic” il nuovo utente; inserire la password due volte per conferma)

3 Creazione del database

# createdb -E UTF8 -O maposmatic db_maposmatic

4 Abilitazione di PostGIS sul database

4.a Abilitare il linguaggio plpgsql sul database creato db_maposmatic (utente postgres)

# createlang plpgsql db_maposmatic

4.b Installazione del supporto PostGIS nel database

# psql -f /usr/share/postgresql/9.4/contrib/postgis-2.2/postgis.sql -d db_maposmatic

4.c Opzionalmente inseriamo anche i commenti

# psql -f /usr/share/postgresql/9.4/contrib/postgis-2.2/postgis_comments.sql -d db_maposmatic

4.d Aggiunta della lista dei sistemi di riferimento spaziale

# psql -f /usr/share/postgresql/9.4/contrib/postgis-2.2/spatial_ref_sys.sql -d db_maposmatic

4.e Cambiare il proprietario delle tabelle

# echo “ALTER TABLE geometry_columns OWNER TO maposmatic; ALTER TABLE spatial_ref_sys OWNER TO maposmatic;” | psql -d db_maposmatic

4.f Aggiungere l’estensione hstore

# echo “CREATE EXTENSION hstore;” | psql -d db_maposmatic

5 Installazione di osm2pgsql

osm2pgsql e’ lo strumento che consente di importare i dati OSM direttamente in un database PostGIS. La guida suggerisce di scaricare la versione da SVN in quanto quello pacchettizato Debian/Ubuntu non e’ abbastanza recente. Ho tentato comunque l’installazione via apt-get ed in realta’ tutto e’ andato bene, quindi:

# apt-get install osm2pgsql

6. Download dei dati dal server OSM

Il download dei dati si puo’ effettuare mediante il servizio offerto da geofabrik.de, per esempio cercando la zona di nostro interesse

In alternativa (nel caso volessimo un’area di dimensioni ridotte e/o comunque ben delimitate da una bounding box (bbox)) possiamo utilizzare il servzio offerto da overpass.osm.rambler.ru. In questo caso utilizziamo wget per scaricare una certa area geografica:

$ wget http://overpass.osm.rambler.ru/cgi/xapi_meta?*%5Bbbox=long_inf,lat_inf,long_sup,lat_sup%5D

tradotto con dati reali potrebbe essere:

$ wget http://overpass.osm.rambler.ru/cgi/xapi_meta?*%5Bbbox=11.3640,45.4650,11.4660,45.5780%5D

Si ottiene un file denominato “xapi_meta?*[bbox=11.4740,45.4150,11.5160,45.4650]” che potremo rinominare in “dati_osm.osm” (per esempio mediante il comando “mv”).

7 Importazione dei dati OSM all’interno del database PostGIS

L’importazione avviene mediante il seguente comando:

$ osm2pgsql -s -c -d db_maposmatic -m -U maposmatic -W -H localhost -k dati_osm.osm

A seconda della dimensione del file .osm il processo puo’ durare qualche secondo, minuto o ora (l’importazione di tutto il nord-est d’Italia, circa 750 MB, e’ durata circa 1 ora e mezza) e dipende molto dalle caratteristiche hardware del computer.

8 Installazione di Mapnik

8.a Installare python-mapnik

Via synaptic o apt-get o compilarlo da sorgente mediante “python setup.py install

8.b Installazione dipendenze

# apt-get build-dep python-mapnik

e installare altre librerie necessarie (in particolare e’ opportuno installare le librerie libboost piu’ recenti. Ad momento della stesura del presente articolo su Debian Testing si trovano le libboost-1.61):

# apt-get install libboost1.61-dev libboost-date-time1.61-dev libboost-filesystem1.61-dev libboost-iostreams1.61-dev libboost-program-options1.61-dev libboost-python1.61-dev libboost-regex1.61-dev libboost-serialization1.61-dev libboost-system1.61-dev libboost-thread1.61-dev libharfbuzz-dev

8.c Download Mapnik

Download dell’ultima versione di Mapnik dal repository git (dopo esseresi posizionati nella directory /home/nome_utente/src/):

$ cd src

Lanciare il download:

$ git clone git://github.com/mapnik/mapnik.git

Spostarsi nella directory creata durante il download “mapnik”:

$ cd mapnik

8.d Compilazione ed installazione

Prima di eseguire il config assicurarsi di fare un update dei submodule di mapnik:

$ git submodule update –init

$ git submodule update –init deps/mapbox/variant

Eseguire il config:

$ python scons/scons.py configure INPUT_PLUGINS=all OPTIMIZATION=3 SYSTEM_FONTS=/usr/share/fonts/ PYCAIRO=true XMLPARSER=libxml2

Compilare:

$ python scons/scons.py

Installare (dopo essersi loggati come root):

# python scons/scon.py install

8.e Controllo dell’installazione

Lanciare un interprete python ed invocare “import mapnik”:

$ python

dovremmo ottenere una cosa del tipo:

Python 2.7.12+ (default, Sep  1 2016, 20:27:38)
[GCC 6.2.0 20160927] on linux2
Type “help”, “copyright”, “credits” or “license” for more information.
>>>

quindi importiamo il modulo mapnik appena compilato:

>>> import mapnik
>>>

Se tutto e’ ok dovremmo ottenere il prompt in attesa di comandi; in tal caso significa che mapnik e’ stato compilato  ed installato correttamente.

9. Installazione di Mapnik-OSM

Mapnik-OSM e’ un set di file che indicano a Mapnik come renderizzare le mappe di OpenStreetMap.

9.a Download

Dopo essersi posizionati nella directory /home/nome_utente/src/ scarichiamo il sorgente mediante svn (nel caso svn non fosse presente installarlo via “apt-get install subversion”)

$ svn co http://svn.openstreetmap.org/applications/rendering/mapnik mapnik2-osm

Questo creera’ una nuova directory in /home/nome_utente/src chiamata “mapnik2-osm”

9.b Installazione dei dati statici generali

In aggiunta ai dati OSM sono necessari altri dati statici (world boundaries, ecc…)

$ cd mapnik2-osm

Invochiamo da shell il comando get-coastlines.sh che scarichera’ una serie di SHP delle linee di costa ed altri dati.

$ sh ./get-coastlines.sh

9.c Abilitazione degli unifont

Per un render corretto dei caratteri Coreano, Cinese o Giapponese si deve usare il font unifont. Per abilitarlo (da root):

# apt-get install ttf-unifont

E’ consigliato eseguire anche un reconfigure del locales:

# dpkg-reconfigure locales

9.d Configurazione

La configurazione avviene invocando lo script in python chiamato “generate_xml.py” che si trova in /home/nome_utente/src/mapnik2-osm/; spostarsi quindi nella directory interessata:

$ cd /home/sit/src/mapnik2-osm/

e lanciare il comando

$ python ./generate_xml.py –dbname db_maposmatic –host ‘localhost’ –user maposmatic –port 5432 –password ‘password_utente_maposmatic’

In risposta dovremmo ottenere un messaggio simile a questo:

Include files written successfully! Pass the osm.xml file as an argument if you want to serialize a new version or test reading the XML

10 Installazione di OCitySMap

10.a Recuperare i sorgenti

Posizionarsi sempre nella directory /home/sit/src/

$ git clone git://git.savannah.nongnu.org/maposmatic/ocitysmap.git

10.b Installazione delle dipendenze

# apt-get install python-psycopg2 python-gdal python-gtk2 python-cairo python-shapely

10.c Modifica di alcuni file di configurazione di OCitySMap

Editare il file /home/nome_utente/src/ocitysmap/ocitysmap/maplib/map_canvas.py alle righe 176 e 177. In particolare modificare la riga 176 nel modo seguente:

r.symbols.append(mapnik.PolygonSymbolizer())

e la riga 177 nel modo seguente:

r.symbols.append(mapnik.LineSymbolizer())

altrimenti durante il processo compariranno degli errori sull’impossibilita’ di eseguire alcuni render.

11 File di configurazione di OcitySMap

copiare il file /home/nome_utente/src/ocitysmap/ocitysmap.conf.dist nella home directory dell’utente e rinominarlo in “.ocitysmap.conf”. Da notare il punto davanti al nome del file: indica che il file e’ nascosto. Editarlo poi inserendo i dati corretti del database da utilizzare. Ecco il file .ocitysmap.conf usato in questa guida:

[datasource]
host=localhost
user=maposmatic
password=password
dbname=db_maposmatic
# Optional database port, defaults to 5432
# port=5432

[rendering]
# List of available stylesheets, each needs to be described by an eponymous
# configuration section in this file.
available_stylesheets: stylesheet_osm1, stylesheet_osm2

# The default Mapnik stylesheet.
[stylesheet_osm1]
name: Default
description: The default OSM style
path: /home/sit/src/mapnik2-osm/osm.xml

# Another stylesheet
[stylesheet_osm2]
name: AnotherOne
description: Another OSM Stylesheet
path: /home/sit/src/ocitysmap/stylesheet/maposmatic-printable/osm.xml

12 Lanciare OCitySMap

Spostarsi nella directory /home/nome_utente/src/ocitysmap/ e lanciare il comando per l’esecuzione del render:

$ ./render.py -t “titole della mappa” -f pdf -p nome_file_generato –osmid=-44831

nel caso si conoscesse l’osmid della relazione (in questo caso identifica un confine comunale) che intendiamo usare. Per ricavare l’osmid consultare l’ottimo servizio fornito da nominatim

lanciando il comando ./render.py –help si ottiene un elenco dettagliato dei comandi opzionali del modulo.

Se invece si volesse effettuare il render di una determinata area geografica e’ possibile indicarla con i valori del bbox, per esempio:

$ ./render.py -t “titolo della mappa” -f pdf -p nome_file_generato -b lat_inf,long_inf lat_sup,long_sup

dove lat_inf e long_inf sono rispettivamente la latitudine e la longitudine dell’estremo inferiore sinistro (o ovest) e lat_sup e long_sup sono rispettivamente la latitudine e longitudine dell’estremo superiore destro (o est). Tradotto don dati reali:

$ ./render.py -t “titolo della mappa” -f pdf -p nome_file_generato -b 45.3330,11.3280 45.4400,11.4595

Verranno generati due file: “nome_file_generato.pdf” contenente la mappa ed un file “nome_file_generato.csv” con l’elengo indicizzato della strade e dei luoghi di interesse trovati.

 

Da Postgresql-8.4 e Postgis-1.5 a Posgresql-9.5 e Postgis-2.2

Riporto le operazioni effettuate per migrare alcuni database da Postgresq-8.4 con estensione spaziale Postgis-1.5 a Postgresql-9.5 con Postgis-2.2.

Eseguire un dump dei dati con:

$ PGUSER=postgres pg_dump -Fc nome_db > nome_db.dmp

Questa operazione va fatta per ogni db presente nel cluster; si ottengono i relativi dump in formato compresso (.dmp) da utilizzare poi per l’importazione della nuova architettura.

Stoppare Postgresql-8.4 con (da root):

# /etc/init.d/postgresql stop 8.4

Installare la versione 9.5 di Postgresql e la versione 2.2 di Postgis (e dipendenze collegate) con:

# apt-get install postgresql-9.5 postgis postgis-2.2

A questo punto si potrebbe droppare il cluster della versione 8.4 con “pg_dropcluster –stop 8.4 main“. Nel mio caso ho invece preferito rimuovere Postgresql-8.4 e Postgis 1.5 con “apt-get purge postgresql-8.4*

Creare gli utenti dei db (nel nostro caso abbiamo ricreato gli utenti che avevamo prima di effettuare la migrazione):

$ su

# su postgres

Entrare in un db (es: template1):

# psql template1

e creare gli utenti necessari:

#= CREATE USER nome_utente WITH PASSWORD ‘password_segreta’ CREATEDB CREATEUSER;

(nel nostro caso l’utente creato avra’ la facolta’ di creare database e utenti)

Creare un template apposito per i db spaziali che chiameremo “template_gis”:

#= CREATE DATABASE template_gis template=template0;

Uscire dal database template1 e (sempre come utente postgres) importare le funzioni spaziali nel database appena creato:

# psql -d template_gis -f /usr/share/postgresql/9.5/contrib/postgis2.2/postgis.sql

# psql -d template_gis -f /usr/share/postgresql/9.5/contrib/postgis2.2/spatial_ref_sys.sql

# psql -d template_gis -f /usr/share/postgresql/9.5/contrib/postgis2.2/rtpostgis.sql

In questo modo abbiamo popolato il template_gis con tutti i sistemi di riferimento spaziali e tutte le funzioni dedicate alla manipolazione di dati vettoriali (“postgis.sql”  e raster “rtpostgis.sql”)

Ritornare all’interno del database template1:

# psql template1

e facciamo in mdo che il database template_gis sia un template:

#= UPDATE pg_database SET datistemplate=’t’ WHERE datname=’template_gis’;

Creare i database (uno alla volta)

#= CREATE DATABASE nome_db template=template_gis OWNER nome_utente;

Uscire dal template1 e popolare i nuovi database con l’aiuto dello script “postgis_restore.pl”:

$ /usr/share/postgresql/9.5/contrib/postgis-2.2/postgis_restore.sql nome_db.dmp | psql nome_db

 

Postgis |unione di poligoni adiacenti

A partire da un layer multipolygon contenente edifici di una porzione di territorio (circa 1300 entità) avevo la necessità ci creare un nuovo layer (tabella) contenente i poligoni ottenuti dalla fusione di elementi adiacenti. La situazione di partenza è quella rappresentata in fig. 1.

buildingfig. 1

Utilizzando le funzioni di Postgis ho ottenuto il risultato mediante la seguente istruzione (viene creata una nuova tabella):

# CREATE TABLE nuova_tabella AS SELECT(ST_Dump(ST_Union(ST_Buffer(the_geom, 0.01)))).geom AS the_geom FROM tabella_origine;

Il risultato è quello di fig. 2

building_unionfig. 2

Se volessimo aggregare i poligoni anche in base al valore di un determinato attributo il comando diventa:

# CREATE TABLE nuova_tabella AS SELECT nome_campo, (ST_Dump(ST_Union(ST_Buffer(the_geom, 0.01)))).geom AS the_geom FROM tabella_origine GROUP BY nome_campo;

QGIS web client | a few tricks and notes

ricerca e zoom sugli oggetti

Affinche’ il sistema di ricerca degli oggetti funzioni correttamente (ottenere lo zoom corretto sull’oggetto identificato) controllare il file “search.wsgi” (in “/wsgi/”) alle linee 59, 60 e 61. Per default viene abilitato un codice che funziona per Postgresql versione >9.0. Per Postgresql < 9.0 commentare la linea 59 e de-commentare la linea 61.

linea 59 # sql += “‘[‘||replace(regexp_replace(BOX2D(the_geom)::text,’BOX\(|\)’,”,’g’),’ ‘,’,’)||’]’::text AS bbox “
linea 60 # if the above line does not work for you, deactivate it and uncomment the next line
linea 61 sql += “‘[‘||replace(regexp_replace(BOX2D(the_geom)::text,’BOX[(]|[)]’,”,’g’),’ ‘,’,’)||’]’::text AS bbox “

Controllare inoltre i parametri di connessione al DB (nel nostro caso Postgresql-Postgis) all’interno del file “/wsgi/search.wsgi” alla riga 86 e all’interno del file “/wsgi/getsearchgeom.wsgi” alla riga 27.

Identify

modificare il file “WebgisInit.js” che si torva in “/site/js/” alle righe 325 e 326.

Per fare in modo che per default (nel menu’ a tendina che compare nell’interfaccia grafica del client) venga interrogato il layer attivo impostare a “activeLayer” il valore del parametro “ObjectIdentificationModeCombobox.setValue” e “identificationMode” come da esempio:

ObjectIdentificationModeCombobox.setValue(“activeLayers”);
                identificationMode = “activeLayers”;

impostare invece il valore “allLayers” per interrogare tutti i layer

ObjectIdentificationModeCombobox.setValue(“allLayers”);
                identificationMode = “allLayers”;

oppure “topMostFit” per interrogare il layer piu’ in alto (nella TOC)

ObjectIdentificationModeCombobox.setValue(“topMostFit”);
                identificationMode = “topMostFit“;

Theme switcher

Modificare il file GISProject Listing.js (in “/site/js/”) per configurare il passaggio da una mappa all’altra. E’ necessario prima di tutto impostare a “true” il valore del parametro

var mapthemeswitcherActive=true;

nel file “GlobaOptions.js”

Per visualizzare una miniatura dei progetti (o temi) sullo switcher creare una immagine (PNG) di dimensioni 300×200 pixel e denominarla “nome_progetto_qgis.png”. Salvarla in “../site/thumbnails/”

Stampa in PDF

Puo’ succedere che nella fase di stampa venga restituito un errore (sul server): per evitarlo nel layout di stampa del progetto “.qgs” impostare “Stampa come raster”.

Se viene configurato il “theme switcher” e’ necessario fare in modo che tutti i layout di stampa abbiamo lo stesso nome (es: A4, A3,..) nei vari progetti altrimenti compare il messaggio:

“Composer template not found”

e la mappa non viene stampata.

QGIS web client | reference map

In QGIS web client la configurazione della mappa di riferimento per la “navigazione” (o panoramica) avviene editando il file GlobalOptions….js (nella directory “../site/js”). Alla voce:

……..
var OverviewMapSize = new OpenLayers.Size(200,150);
var overviewLayer = new OpenLayers.Layer.WMS(“Overview Map”,
  “/cgi-bin/qgis_mapserv.fcgi?map=/var/www/qgiswc/projects/nome_progetto.qgs”,
  {layers:”nome_layer01,nome_layer02,nome_layer03″,format:”image/jpeg”},
  {buffer:0,singleTile:true,transitionEffect:”resize”});
……..

La parte importante e’ “/cgi-bin/qgi…” che deve puntare al file di progetto corretto ed il nome del layer (uno o piu’ separati da virgola) da utilizzare.

NB: assicurarsi che il layer da utilizzare come overview non abbia limiti di scala di visualizzazione altrimenti (essendo la panoramica una vista a scala molto piccola) non compare.

QGIS | conditional labeling

QGIS si rivela (almeno per le mie necessita’) uno strumento sempre piu’ potente e versatile. A riguardo lascio un breve post su come impostare una etichettatura condizionale. Per spiegarsi: come fare per visualizzare le etichette (label) solamente di determinati oggetti di un layer (nel mio caso PostGIS)? Per questo devo ringraziare la lista qgis-users ed in particolare Andreas Neumann, Giuseppe Sucameli, Nathan Woodrow, Martin Dobias e Mayeul Kauffmann per avere sollevato la questione ed averne indicato la soluzione.

Nel mio caso specifico volevo “etichettare” soltanto alcune zone territoriali omogenee di PRG: in particolare le zone A, B, C, e D tralasciando quelle a servizi ed agricole (E ed F). Nella tabella attributi del layer vettoriale poligonale si trova un campo chiamato “AmbitoIdZona” che contiene le informazioni necessarie.

– Apriamo lo strumento “Layer Labeling Options” cliccando sull’icona relativa o tramite la finestra delle proprieta’ del layer interessato.

– Spuntiamo il tick “Etichetta questo vettore” e clicchiamo sul pulsante “Modifica espressione” (quello con il simbolo dell’espressione);

– Nel frame in basso scriviamo l’espressione:

CASE WHEN “AmbitoIdZona” IN (‘A’,’B’,’C’,’D’) THEN “AmbitoIdZona” || ‘;’ || “NumeroZona” END

Nota: nell’espressione l’etichetta comprende il valore di due campi “AmbitoIdZona” e “NumeroZona”. Il punto e virgola ‘;’ indica di andare a capo. Questa impostazione si configura nella sezione “Formattazione” ed in particolare valorizzando il campo “A capo con il carattere” nel quale si indica un carattere a piacere (nel mio caso il ‘;’ appunto).

 

Aggiornamento: come impostare etichette di colore diverso a seconda del valore contenuto nel campo da etichettare o in altro campo

Facciamo un esempio concreto: ho un layer poligonale che riporta gli ambiti di alcuni strumenti urbanistica attuativi. Uno dei tanti attributi si chiama “Stato” che puo’ contenere i due valori: ‘vigente’ o ‘decaduto’. Vogliamo fare in modo che l’etichetta riporti il nome dello strumento urbanistico (dato che risiede nel campo “Nome”) e sia di colore rosso se lo “Stato”=’decaduto’ e di colore verde se “Stato”=’vigente’.

Andiamo sulle proprietà del layer e ci posizioniamo sulla scheda “Etichette” quindi su “Testo”. Definiamo un colore di default (nel nostro caso il verde con RGB=0,255,0 e poi clicchiamo sull’icona riportata a destra “Sovrascrittura definita dai dati (espressione)”. Compare la finestra di configurazione dell’espressione e digitiamo quanto segue:

CASE WHEN nome_campo=’valore’ THEN color_rgb(255,0,0) END

che tradotto riportando i nostri dati diventa:

CASE WHEN “Stato”=’decaduto’ THEN color_rgb(255,0,0) END

In questo modo vedremo le etichette (il testo dell’etichetta) rosse nel caso in cui il campo “Stato” ha valore=’decaduto’ e verdi negli altri casi

 

 

GRASS GIS fund raising per Vienna Code Sprint 2014

Con molto piacere pubblico questa richiesta fondi per il prossimo GRASS GIS Code Sprint di Vienna
 
 
“Dear GRASS GIS Users,
 
In the occasion of the upcoming Vienna Code Sprint 2014 [1], the GRASS GIS Project Steering Committee decided to officially join this code sprint, considering the great opportunity for joint activities. More than 60+ developers from the most important OSGeo project communities will join the event.
While the GRASS developers are donating their valuable time, the community of enthusiast users may contribute with donations, even symbolic, that will be used to cover out-of-pocket expenses of the participants.
Companies can also decide to sponsor specific tasks! Please don’t hesitate to contact us for further details.
As usual, all of the work done in the community sprint will be directly contributed back to the GRASS project for the benefit of everyone who uses it. The scope is to publish a first release candidate of the stable GRASS GIS 6.4.4 version as well as a tech preview release of GRASS GIS 7. For further information don’t hesitate to contact Markus Neteler (neteler@osgeo.org).
 
For your convenience, here our easy-to-use Paypal button:
 
For our alternative bank transfer option, please contact Martin Landa (landa.martin
@gmail.com)”
 
Thanks for your support!
The GRASS Developers Team
 
 
 
 
About GRASS GIS
The Geographic Resources Analysis Support System (http://grass.osgeo.org/), commonly referred to as GRASS GIS, is an Open Source Geographic Information System providing powerful raster, vector and geospatial processing capabilities in a single integrated software suite. GRASS GIS includes tools for spatial modeling, visualization of raster and vector data, management and analysis of geospatial data, and the processing of satellite and aerial  imagery. It also provides the capability to produce sophisticated presentation graphics and hardcopy maps. GRASS GIS has been translated into about twenty languages and supports a huge array of data formats. It can be used either as a stand-alone application or as backend for other software packages such as QGIS and R geostatistics. It is distributed freely under the terms of the GNU General Public License (GPL). GRASS GIS is a founding member of the Open Source Geospatial Foundation (OSGeo).

GRASS, QGIS | individuare collina e pianura di un territorio

Un collega mi ha chiesto di indicargli le percentuali di territorio (comunale) pianeggiante e collinare.

Avevo a disposizione un DEM con risoluzione 5m (realizzato con GRASS a partire dalle curve di livello della CTRN) ed il vettoriale del limite amministrativo.Tuttavia il DEM (chiamato dem_5m) ricopre un’area pressochè rettangolare ben più ampia del limite del comune ed avevo la necessità di “clipparlo” sul boundary di interesse. Ho agito per passi successivi utilizzando GRASS dall’interno di QGIS.

L’immagine sottostante illustra la situazione di partenza (dem e confine):

dtm e confine

dtm a 5 m e confine comunale

Ecco i passi seguiti:

– conversione del vettoriale del confine comunale in raster:

$ v.to.rast input=confine_comune out=confine_comune (comando lanciato dalla shell del plugin qgis grass)

– impostazione della regione di lavoro sul raster appena creato:

$ g.region rast=confine_comune res=5

– creazione di una MASK dal confine per clippare il dem su di esso in un secondo momento:

$ r.mask input=confine_comune

– clip del dem per delimitarlo al territorio comunale (con r.mapcalc); si ottiene un raster che chiameremo “dem_comune”:

$ r.mapcalc “dem_comune=dtm_5m – confine_comune”

– calcolo del territorio considerato collinare (da una stima si è deciso di considerare tale il territorio con quota > 120 m s.l.m. in quanto rappresenta la quota media del piede di collina dell’area di lavoro):

$ r.mapcalc “collina=dem_comune>120”

– e calcolo della pianura con il territorio che rimane a complemento:

$ r.mapcalc “pianura=dem_comune<=120”

Il risultato è il seguente:

i raster "collina" e "pianura" caricati con trasparenza al 50%

i raster “collina” e “pianura” caricati con trasparenza al 50%

Il passaggio succesivo consiste nel trasformare i raster in vettori mediante il modulo “r.to.vect“. Il calcolo della superficie e, di conseguenza, l’incidenza percentuale delle due porizioni di territorio sul totale vengono tralasciati (basta consultare le aree con lo strumento di interrogazione di QGIS o lanciare il modulo “v.report” in GRASS).

TileMill | prima installazione su Debian

In questo breve post volevo tenere traccia delle operazioni eseguite per installare TileMill su Debian. Sul sito si trovano i pacchetti per Ubuntu, Mac OS X e Windows…..Io uso Debian in genere (anche i due timidi serverini che gestisco) e volevo capire se era fattibile: si!

Ho seguito passo-passo le istruzioni riportate nella pagina “Building from source” e ne riassumo i passi salienti:

– controllare di avere i python development headers, libbz2, libicu, boost, icu, proj4 ed altre svariate librerie di immagini (synaptic aiuta molto);

– installare boost da sorgente (la versione pacchettizzata per Debian non è aggiornata) seguendo questi passi:

(piccolo inciso: in genere – ma questa è una mia prassi – le compilazioni le faccio all’interno di una directory chiamata “src” e per ogni pacchetto creo una subdirectory ad hoc).

creare una directory per la compilazione:

$ mkdir boost

spostarsi nella dir creata:

$ cd boost

scaricare il sorgente con:

$ wget http://voxel.dl.sourceforge.net/project/boost/boost/1.51.0/boost_1_51_0.tar.bz2

decomprimere il tar:

$ tar xjvf boost_1_51_0.tar.bz2

spostarsi nella dir ottenuta dalla decompressione:

$ cd boost_1_51_0

lanciare il comando

$ ./bootstrap.sh

poi in sequenza:

$ ./b2 stage toolset=gcc –with-thread –with-filesystem –with-python –with-regex -sHAVE_ICU=1 -sICU_PATH=/usr/ –with-program_options –with-system link=shared

$ ./b2 install toolset=gcc –with-thread –with-filesystem –with-python –with-regex -sHAVE_ICU=1 -sICU_PATH=/usr/ –with-program_options –with-system link=shared

infine autenticarsi come root ed impartire:

# ldconfig

Poi installare anche boost >= 1.47, icu, proj4, libpng, libjpeg, libtiff, libxml2, libltdl, e freetype (a meno di averle già)

– Passiamo ora all’installazione di Mapnik (motore di rendering per TileMill). Come prima creiamo una dir per la compilazione:

$ mkdir mapnik

ci spostiamo nella dir

$ cd mapnik

e scarichiamo il sorgente con:

$ wget https://github.com/downloads/mapnik/mapnik/mapnik-v2.1.0.tar.bz2

decomprimiamo:

$ tar xf mapnik-v2.1.0.tar.bz2

ci spostiamo nella nuova directory:

$ cd mapnik-v2.1.0

e lanciamo il configure:

$ ./configure (durante il configure sono stato avvisato della mancanza di alcune librerie – che mi erano sfuggite – le ho quindi installate con synaptic e poi ho reimpartito il configure)

poi il make

$ make

ed infine il make install (come root):

# make install

– E’ la volta di Node.js: compiliamo anche questo (come prima creiamo la dir di lavoro):

$ mkdir nodejs

ci spostiamo della dir nuova:

$ cd nodejs

scarichiamo il sorgente:

$ wget http://nodejs.org/dist/v${VERSION}/node-v${VERSION}.tar.gz (nel mio caso ho scaricato la versione v0.8.14 quindi la stringa “v${VERSION}” diventa “v0.8.14”)

decomprimiamo:

$ tar xf node-v0.8.14.tar.gz

ci spostiamo nella dir:

$ cd node-v0.8.14

e lanciamo configure, make e make install

$ ./configure && make

e come root:

# make install

Prima di passare all’installazione di TileMill installare un’altra dipendenza chiamata “libwebkit-dev” che si può tranquillamente installare con “apt-get install libwebkit-dev”

Ed ora passiamo a TileMill:

$ mkdir tilemill

ci spostiamo nella dir:

$ cd tilemill

scarichiamo il sorgente:

$ git clone https://github.com/mapbox/tilemill.git

poi si entra nella dir ottenuta:

$ cd tilemill

ed infine si installa tutto mediante “npm”

# npm install

<inizio NB>:La prima volta che ho lanciato “npm install” il comando è terminato con degli errori riferiti a nodejs. La causa era una versione troppo recente di nodejs avendo inizialmente installato la versione v0.9.1. Installando la v0.8.14 dopo avere rimosso la v0.9.1 tutto è andato a buon fine. La rimozione di nodejs si può fare così (fonte il mitico stackoverflow):

– lanciare il comando “which node” che dovrebbe ritornare qualcosa come “/usr/local/bin/node”

– poi ci spostiamo in /usr/local/bin/node”

– e lanciamo come root:

# rm -r bin/node bin/node-waf include/node lib/node lib/pkgconfig/nodejs.pc share/man/man1/node.1

Poi possiamo ritornare a scaricare la nuova versione di nodejs ed a ricompilare. <fine /NB>

Una volta che tutto è compilato lanciare il comando:

$ ./index.js

compare l’interfaccia di TileMill. Analogo risultato si ottiene mediante un browser puntando su “http://localhost:20009&#8221;.

Ed ecco un paio di screenshot:

Tile Mill versione desktop

Tile Mill versione web

il mio primo “hello world” con TileMill