domenica 7 dicembre 2008

Compilare GDAL e GRASS in Ubuntu Intrepid Ibex

Resoconto di una compilazione portata a termine da un principiante.

Ho faticato molto per installare GRASS e GDAL , soprattutto perchè non avevo letto attentamente quanto segue:

  1. la pagina apposita del wiki di GRASS;

  2. la pagina dedicata al plugin GRASS-GDAL ;

  3. questa utilissima guida;

  4. il file README che spiega i requisiti per l'interfaccia wxPython di GRASS ;

  5. il file README che accompagna il sorgente del plugin GRASS-GDAL .

In pratica questi appunti sono un sintetico riassunto di quanto sopra nonchè una semplice relazione di cosa ho fatto. Nel dubbio fare affidamento sulla documentazione sopra citata... (questi sono appunti scritti da un novellino, possono servire come traccia (vaga) ma non come regola).

Requisiti

Lavorando in Ubuntu 8.10 ho dovuto per prima cosa installato una certa quantità di pacchetti che risultavano mancanti, tra i quali molti dev:

$ sudo apt-get update && sudo apt-get upgrade
$ sudo apt-get install bison build-essential byacc \
fftw3 fftw3-dev flex freeglut3-dev libavcodec-dev \
libfreetype6-dev libgcc1 libgdal1-dev libgl1-mesa-dev \
libjpeg-dev libjpeg62-dev libncurses5-dev libpng12-dev \
libpq-dev libreadline5 libreadline5-dev libsqlite3-dev \
libtiff4-dev libxmu-dev libxmu-dev tk8.5-dev zlib1g-dev

Inoltre ho installato i seguenti pacchetti:

$ sudo apt-get install libwxbase2.8-0 libwxbase2.8-dbg libwxbase2.8-dev  \
libwxgtk2.8-0 libwxgtk2.8-dbg libwxgtk2.8-dev \
python-wxgtk2.8 wx2.8-doc wx2.8-examples \
wx2.8-headers wx2.8-i18n wx-common

Occorre inoltre controllare che GEOS e PROJ siano installati (controllare con Synaptic l'esistenza di pacchetti dev).

Ulteriori pacchetti dev potrebbero essere richiesti (vedere dopo).

I sorgenti

Ho deciso di avere tutti i sorgenti in /usr/local/src/.

Per prima cosa ho creato la cartella e ho fatto in modo che anche l'utente normale (non root) vi potesse scrivere:

$ sudo mkdir /usr/local/src
$ sudo chown mionomeutente:miogruppo /usr/local/src/

Mi sono posizionato in tale cartella e ho scaricato i sorgenti di GDAL con svn (che può essere installato con Synaptic):

$ cd /usr/local/src
$ svn checkout https://svn.osgeo.org/gdal/trunk/gdal gdal

viene scaricata la versione in sviluppo (questo può avere vantaggi e qualche svantaggio...) all'interno di una cartella denominata gdal.

La stessa operazione per GRASS :

$ cd /usr/local/src
$ svn checkout https://svn.osgeo.org/grass/grass/branches/develbranch_6 grass6_devel

viene creata la cartella /usr/local/src/grass6_devel con tutti i sorgenti di GRASS .

Infine ho scaricato da qui il file gdal-grass-1.4.3.tar.gz in /usr/local/src ed ho scompattato tale file (tar xvfz gdal-grass-1.4.3.tar.gz).

Compilare

La compilazione deve avvenire secondo un ordine preciso:

  1. GDAL

  2. GRASS

  3. plugin GRASS-GDAL

Regola generale: si configura (configure), si compila (make) e si installa (make install).

GDAL

Per configurare GDAL :

$ cd /usr/local/src/gdal
$ ./configure \
--with-pg=/usr/bin/pg_config \
--prefix=/usr/local \
--with-python \
--with-ogdi \
--with-sqlite \
--with-mysql=/usr/bin/mysql_config \
--with-libtiff=internal \
--without-grass \
--with-libtiff=internal

Non essendo farina del mio sacco rimando alla documentazione richiamata all'inizio per comprendere il significato delle diverse opzioni, nonchè all'help che può essere visualizzato digitando:

$ ./configure --help

Quello che davvero è importante è che GDAL deve esssere compilato senza il supporto di GRASS (--without-grass).

Il risultato di configure è il seguente:

GDAL is now configured for i686-pc-linux-gnu

Installation directory: /usr/local
C compiler: gcc -g -O2
C++ compiler: g++ -g -O2

LIBTOOL support: yes

LIBZ support: external
GRASS support: no
CFITSIO support: no
PCRaster support: internal
NetCDF support: yes
LIBPNG support: external
LIBTIFF support: internal (BigTIFF=yes)
LIBGEOTIFF support: internal
LIBJPEG support: external
LIBGIF support: external
OGDI support: no
HDF4 support: yes
HDF5 support: yes
Kakadu support: no
JasPer support: yes (GeoJP2=yes)
ECW support: no
MrSID support: no
MSG support: no
GRIB support: yes
cURL support (wms/wcs/...):yes
PostgreSQL support: yes
MySQL support: yes
Ingres support: no
Xerces-C support: yes
NAS support: no
Expat support: yes
ODBC support: yes
PGeo support: yes
OCI support: no
GEORASTER support: no
SDE support: no
DODS support: no
SQLite support: yes
DWGdirect support no
INFORMIX DataBlade support:no
GEOS support: yes


Old-gen python no
SWIG Bindings: python

Statically link PROJ.4: no
enable OGR building: yes
enable pthread support: no
hide internal symbols: no

Controllare tutte le voci del resoconto di configure; ci possono essere difficoltà legate al fatto che non si hanno abilitate librerire per alcune tipologie di file. In questo caso si può:

  1. cercare le librerie in Synaptic (pacchetti deb);

  2. cercare indicazioni nel wiki e negli archivi della mailing list;

  3. cercare indicazioni nella mailing list di GRASS ;

  4. cercare in Google;

  5. postare un quesito in qualche mailing list.

Qualora non si proceda alla compilazione ma, dopo modifiche, si vuole riconfigurare (cioè impartire un'altra volta il comando ./configure...), occorre sempre cancellare i file di configurazione creati con il precedente ./configure.

Ricordare:

make clean:
cancella ogni file creato da make;
make distclean:
cancella ogni file creato da make e ogni files creato dal ./configure.

Quindi, prima di ri-eseguire ./configure occorre make distclean.

A questo punto inizia la compilazione:

$ make

Se non vengono segnalati errori dopo la compilazione si procede all'installazione

$ sudo make install 

Se non specificato diversamente durante la fase di configurazione:

i binari di GDAL (ogr2ogr, gdalwarp, ectc.): vengono installati in /usr/local/bin. Per poterli usare questa cartella deve essere contenuta nei percorsi di ricerca dei comandi (vedi qui per capire cos'è un percorso di ricerca di comandi e cos'è la variabile PATH); se necessario quindi occorre modificare la variabile di ambiente PATH; tra gli infiniti esempi di come farlo vedere qui;

le librerie di GDAL (es.: libgdal.so.1.13.0): vengono posizionate in /usr/local/lib; anche queste devono poter essere viste (condivise). Si vedrà dopo cosa fare al riguardo.

GRASS

Leggere i files README e INSTALL nella directory /usr/local/src/grass6_devel/.

Molte delle cose dette al riguardo della compilazione di GDAL valgono anche per GRASS .


$ cd /usr/local/src/grass6_devel/
$ CFLAGS="-g -Wall" LDFLAGS="-s" ./configure \
--with-tcltk-includes=/usr/include/tcl8.5 \
--with-postgres=yes \
--with-postgres-includes=/usr/include/postgresql \
--with-sqlite \
--with-cxx \
--with-blas \
--with-lapack \
--with-cairo \
--with-fftw \
--with-freetype=yes \
--with-freetype-includes=/usr/include/freetype2 \
--with-readline \
--with-opengl-includes=/usr/include/GL \
--with-mysql \
--with-mysql-includes=/usr/include/mysql \
--with-python=/usr/bin/python2.5-config \
--with-wxwidgets=/usr/bin/wx-config \
--enable-largefile=yes \
--with-proj-includes=/usr/include \
--with-proj-share=/usr/share/proj \
--with-proj-libs=/usr/lib

Controllare che sul sistema in uso i percorsi richiamati esistano realmente. Per il supporto blas/lapack ho fatto ricorso a Synaptic installando alcuni pacchetti.

Più o meno quanto sopra riportato è preso da qui, dove, tra le molte altre cose interessanti, si legge:

Think twice before using this script. Some users experienced
problems such as disabled XGL etc.
...

Al termine della procedura di configurazione ottengo un resoconto come questo:

GRASS is now configured for:  i686-pc-linux-gnu

Source directory: /usr/local/src/grass6_devel
Build directory: /usr/local/src/grass6_devel
Installation directory: ${prefix}/grass-6.4.svn
Startup script in directory: ${exec_prefix}/bin
C compiler: gcc -g -Wall
C++ compiler: c++ -g -O2
Building shared libraries: yes
64bit support: no
OpenGL platform: X11
MacOSX application: no

NVIZ: yes

BLAS support: yes
C++ support: yes
Cairo support: yes
DWG support: no
FFMPEG support: no
FFTW support: yes
FreeType support: yes
GDAL support: yes
GLw support: no
JPEG support: yes
LAPACK support: yes
Large File support (LFS): yes
Motif support: no
MySQL support: yes
NLS support: no
ODBC support: no
OGR support: yes
OpenGL support: yes
PNG support: yes
PostgreSQL support: yes
Python support: yes
Readline support: yes
SQLite support: yes
Tcl/Tk support: yes
wxWidgets support: yes
TIFF support: yes
X11 support: yes

Valgono le stesse considerazioni fatte per GDAL ; se non si vede il supporto per un qualcosa di proprio interesse:

  • provare ad installare il qualcosa con Synaptic (installare anche il corrispondente pacchetto dev);

  • si modifichino le opzioni dello script configure in accordo con l'help (./configure --help) in funzione delle proprie esigenze (ricordare: make distclean cancella ogni file creato da make e ogni files creato dal ./configure);

  • cercare nella mailing list di GRASS , nel wiki, ecc.

È ovvio che per avere GRASS con la nuova interfaccia occorre abilitare il supporto a Python e a wxPython (--with-python e --with-wxwidgets); al riguardo può essere letto questo documento.

Se la configurazione fornisce i risultati desiderati si passa alla compilazione:

$ make

che richiede abbastanza tempo. Al termine dovrebbe esserci un messaggio tipo questo:

GRASS GIS compilation log
-------------------------
Started compilation: sab dic 6 12:20:39 CET 2008
--
Errors in:
No errors detected.
--
Finished compilation: sab dic 6 12:30:58 CET 2008

Si passa alla compilazione di vdigit come spiegato qui:

  1. cerco le librerie _gdi_.so:

    $ locate _gdi_.so
  2. creo un link simbolico con le librerie trovate

    $ sudo ln -s /usr/lib/python2.4/site-packages/wx-2.8-gtk2-unicode/wx/_gdi_.so \
    /usr/local/lib/libgdi.so
  3. compilo vdigit:

    $ cd gui/wxpython/vdigit
    $ make

ritorno nella directory /usr/local/src/grass6_devel e

$ sudo make install 

Affinchè le librerire condivise possano essere realmente tali (cioè...condivise!) ho modficato il file etc/ld.so.conf in questo modo:

$ cat /etc/ld.so.conf
include /etc/ld.so.conf.d/*.conf
/usr/local/lib
/usr/local/grass-6.4.svn/lib

Tale file deve essere editato con i privilegi di superutente (es.: gksu gedit /etc/ld.so.conf).

Ricordarsi di dare il comando sudo ldconfig dopo aver aggiornato il file etc/ld.so.conf.

Plugin GRASS /GDAL

GRASS dipende da GDAL ; GDAL dipende da GRASS . Questo plugin risolve il problema dell'interdipendenza. Leggere questo:

$ cd /usr/local/src/gdal-grass-1.4.3/
$ cat README | less

Seguendo questa guida, ho proseguito così:

$ cd /usr/local/lib/ 
$ sudo ln -s /usr/local/grass-6.4.svn/lib/*.so .
$ cd /usr/local/src/gdal-grass-1.4.3/
./configure --with-gdal=/usr/local/bin/gdal-config \
--with-grass=/usr/local/grass-6.4.svn
$ make
$ sudo mkdir /usr/local/lib/gdalplugins
$ sudo cp *.so /usr/local/lib/gdalplugins/

Nella directory /usr/local/lib/gdalplugins/ vengono copiati due files: gdal_GRASS.so e ogr_GRASS.so.

Compilazioni successive

GDAL

sudo apt-get update && sudo apt-get upgrade
make distclean
svn up
U ogr/ogrsf_frmts/grass/ogrgrassdatasource.cpp
U frmts/grass/grass57dataset.cpp
U frmts/grass/GNUmakefile
Aggiornato alla revisione 15902.

GRASS

sudo apt-get update && sudo apt-get upgrade
cd /usr/local/src/grass6_devel/
make distclean
svn up
U scripts/r.colors.stddev/r.colors.stddev
U vector/v.category/main.c
U lib/driver/Polygon.c
U ps/ps.map/description.html
U ps/ps.map/ps_vlegend.c
U gui/wxpython/gui_modules/menudata.py
U gui/tcltk/gis.m/gmmenu.tcl
U gui/tcltk/gis.m/Makefile

U gui/tcltk/d.m/Makefile
U gui/tcltk/d.m/menu.tcl
Aggiornato alla revisione 34740.

Plugin GDAL-GRASS

Controllare se qui esiste una nuova versione. Ripetere le operazioni già esposte

Nessun commento:

Posta un commento