GRASS logo

NOME

r.mapcalc

DESCRIZIONE

r.mapcalc esegue calcoli su tematismi raster. Possono essere creati nuovi tematismi raster che sono espressioni aritmetiche i cui termini comprendono tematismi raster esistenti, costanti di numeri interi o a virgola mobile e funzioni.

USO DEL PROGRAMMA

Se usato da riga di comando senza argomenti, r.mapcalc legge i suoi input, una riga alla volta, dallo standard input (la tastiera, a meno che non sia ridiretto da un file o attraverso una pipe). Altrimenti, viene valutata l'espressione sulla riga di comando. r.mapcalc richiede l'input nella forma:

risultato=espressione

dove risultato è il nome di un tematismo raster che deve contenere i risultati del calcolo e espressione è qualsiasi espressione aritmetica valida tra i cui termini compaiano tematismi raster esistenti, costanti di numeri interi o a virgola mobile, e funzioni note al calcolatore. Nelle espressioni sono consentite le parentesi, anche nidificate con qualsiasi livello di profondità. Il raster risultato verrà creato nel mapset corrente dell'utente.

La formula inserita in r.mapcalc dall'utente viene registrata sia nel titolo della mappa risultato (che appare nel file delle categorie del raster risultato) che nel file della cronologia del raster risultato.

Alcuni caratteri hanno un signicato particolare nella shell. Se l'utente immette un input in r.mapcalc sulla riga di comando le espressioni devono essere racchiuse tra apici singoli. Si veda NOTE, più avanti.

OPERATORI E ORDINE DI PRECEDENZA

Sono supportati i seguenti operatori:
     Operatore   Significato                Tipo           Precedenza
     --------------------------------------------------------------
     -          negazione                  Aritmetico      12
     ~          complemento a uno          Bit a bit       12
     !          not                        Logico          12
     ^          esponenziazione            Aritmetico      11
     %          modulo                     Aritmetico      10
     /          divisione                  Aritmetico      10
     *          moltiplicazione            Aritmetico      10
     +          addizione                  Aritmetico       9
     -          sottrazione                Aritmetico       9
     <<         scorrimento a sinistra     Bit a bit        8
     >>         scorrimento a destra       Bit a bit        8
     >>>        scorr. a destra (unsigned) Bit a bit        8
     >          maggiore di                Logico           7
     >=         maggiore o uguale a        Logico           7
     <          minore di                  Logico           7
     <=         minore o uguale a          Logico           7
     ==         uguale                     Logico           6
     !=         diverso                    Logico           6
     &          and bit a bit              Bit a bit        5
     |          or bit a bit               Bit a bit        4
     &&         and logico                 Logico           3
     &&&        and[1] logico              Logico           3
     ||         or logico                  Logico           2
     |||        or[1] logico               Logico           2
     ?:         condizionale               Logico           1
(il modulo è il resto della divisione)

[1] Gli operatori &&& e ||| trattano i valori null diversamente dagli altri operatori. Per maggiori dettagli si veda più avanti la sezione intitolata Informazioni sul valore NULL .

Gli operatori vengono applicati da sinistra verso destra; quelli con precedenza più alta vengono applicati prima di quelli aventi precedenza più bassa. La divisione per 0 e il modulo per 0 sono possibili e danno come risultato NULL. Gli operatori logici danno come risultato 1 se il confronto è true (vero), 0 altrimenti.

NOME DEI TEMATISMI RASTER

Tutto ciò che in un'espressione non è numero, operatore o nome di funzione viene riconosciuto come nome di un tematismo raster. Esempi:

elevation
x3
3d.his

La maggior parte dei tematismi raster adottano questa convenzione per i nomi dei file. Comunque, se un tematismo raster ha un nome che entra in conflitto con la regola suddetta, dovrebbe essere racchiuso fra virgolette. Per esempio, l'espressione

x = a-b

verrebbe interpretata come: x è uguale ad a meno b, mentre

x = "a-b"

verrebbe interpretata come: x è uguale al tematismo raster a-b

Inoltre

x = 3107

creerebbe un raster x riempito col numero 3107, mentre

x = "3107"

copierebbe il tematismo raster 3107 nel tematismo raster x.

Non sono richieste le virgolette a meno che i nomi dei tematismi raster non appaiano come numeri o contengano operatori, OPPURE a meno che il programma non venga eseguito in modo non interattivo. Gli esempi sotto riportati presuppongono che il programma venga eseguito in modo interattivo. Si veda più avanti NOTE.

r.mapcalc cercherà il tematismo raster seguendo il percorso di ricerca del mapset corrente dell'utente. È possibile ignorare il percorso di ricerca e specificare il mapset dal quale selezionare il tematismo raster. Lo si può fare specificando il tematismo raster nella forma:

nome@mapset

Per esempio, la seguente espressione è valida:

risultato = x@PERMANENT / y@SOILS

Non è necessario che il mapset specificato sia nel percorso di ricerca del mapset. (Questo metodo di sovrascrivere il percorso di ricerca del mapset è comume a tutti i comandi di GRASS, non è un'esclusiva di r. mapcalc.)

IL MODIFICATORE DI VICINATO

Le mappe e le immagini sono file di basi di dati memorizzati in formato raster, cioè matrici bidimensionali di valori interi. In r.mapcalc, i nomi di mappa possono essere seguiti da un modificatore di vicinato (neighborhood), che definisce una posizione relativa da calcolare a partire dalla cella corrente. Il formato è mappa[r,c], dove r è la distanza espressa come numero di righe e c è la distanza espressa come numero di colonne. Per esempio, mappa[1,2] si riferisce alla cella posta una riga sotto e due colonne a destra della cella corrente, mappa[-2,-1] si riferisce alla cella posta due righe sopra e una colonna a sinistra della cella corrente, e mappa[0,1] si riferisce alla cella posta una colonna a sinistra della cella corrente. Questa sintassi permette lo sviluppo di filtri del tipo "di vicinato" all'interno di una singola mappa o attraverso mappe multiple.

VALORI DI UN TEMATISMO RASTER DAL FILE DELLE CATEGORIE

A volte è utile usare un valore associato all'etichetta (label) delle categorie invece del valore stesso. Se un nome di un tematismo raster è preceduto dall'operatore @, nell'espressione vengono usate le etichette del file delle categorie del tematismo raster al posto del valore delle categorie.

Per esempio, si supponga che il tematismo raster soil.ph (che rappresenta i valori di pH del suolo) abbia un file delle categorie con le etichette definite in questo modo:

cat	label
------------------
0	no data
1	1.4
2	2.4
3	3.5
4	5.8
5	7.2
6	8.8
7	9.4

L'espressione:

risultato = @soils.ph

produrrà un risultato con i valori delle categorie 0, 1.4, 2.4, 3.5, 5.8, 7.2, 8.8 e 9.4.

Da notare che questo operatore può essere applicato solo ai tematismi raster e che produce nell'espressione un valore a virgola mobile, per cui le etichette delle categorie devono iniziare con un numero valido. Se l'etichetta è un intero, verrà rappresentata da un numero a virgola mobile. Se l'etichetta non inizia con un numero o manca, verrà rappresentata con NULL (nessun dato) nel raster risultante.

EQUIVALENTI IN SCALA DI GRIGI E SEPARAZIONI DI COLORE

Spesso è utile manipolare i colori assegnati alle categorie. Questo è particolarmente utile quando le proprietà spettrali delle celle hanno un significato (come per i dati delle immagini), o quando i valori delle categorie rappresentano quantità reali (come quando i valori delle categorie riflettono i reali valori dell'altitudine). La manipolazione dei colori della mappa inoltre può essere d'aiuto nella ricognizione visiva e nella stampa delle mappe.

L'operatore # può essere usato sia per convertire i valori delle categorie nei loro livelli di grigio equivalenti o per estrarre le componenti del rosso, del verde e del blu di un tematismo raster in tematismi raster separati.

risultato = #mappa

converte il valore di ogni categoria del raster mappa in un valore, nel campo di variazione 0-255, che rappresenta il livello di grigio corrispondente al colore assegnato alla categoria. Se la mappa ha una tavola dei colori in scala di grigi, il livello di grigio considerato da #mappa è quello. Altrimenti, viene calcolato come:

 0.10 * red + 0.81 * green + 0.01 * blue

In alternativa si può usare:

risultato = y#mappa

per usare le pesature NTSC:

 0.30 * red + 0.59 * green + 0.11 * blue

Oppure, si può usare:

risultato = i#mappa

per dare uguale peso ai colori primari:

 0.33 * red + 0.33 * green + 0.33 * blue

L'operatore # ha altre tre forme: r#mappa, g#mappa, b#mappa. Queste estraggono le componenti rispettivamente del rosso, del verde e del blu nella mappa raster. Lo script di shell di GRASS r.blend estrae ciascuna di queste componenti da due tematismi raster, e le combina secondo una percentuale definita dall'utente. Queste forme permettono di fare separazioni di colore. Per esempio, per estrarre la componente del rosso da mappa e memorizzarla nella nuova mappa rosso con 0-255 gradazioni di colore, l'utente potrebbe scrivere:

rosso = r#mappa

Per assegnare a questa mappa tonalità di grigio:

r.colors map=rosso color=rules
black
white

Per assegnare a questa mappa tonalità di rosso:

r.colors map=rosso color=rules
black
red

FUNZIONI

Le funzioni attualmente supportate sono elencate nella tabella che segue. Il tipo di risultato è indicato nell'ultima colonna. F significa che la funzione dà sempre come risultato un valore a virgola mobile, I significa che la funzione dà come risultato un intero, e * indica che il risulato è a virgola mobile se almeno uno degli argomenti della funzione è un valore a virgola mobile e intero se tutti gli argomenti sono valori interi.

funzione		descrizione					tipo
---------------------------------------------------------------------------
abs(x)			restituisce il valore assoluto di x		*
acos(x)			inverso del coseno di x (risultato in gradi)	F
asin(x)			inverso del seno di x (risultato in gradi)	F
atan(x)			inverso della tangente di x (ris. in gradi)	F
atan(x,y)		inverso della tangente di y/x (ris. in gradi)	F
cos(x)			coseno x (x è in gradi)				F
double(x)		converte x in virgola mobile precisione doppia	F
eval([x,y,...,]z)	valuta le espr. elencate, passa il risultato a z
exp(x)			funzione esponenziale di x			F
exp(x,y)		x elevato y					F
float(x)		converte x in virgola mobile precisione singola	F
graph(x,x1,y1[x2,y2..])	converte la x in una y basata sui punti in un grafo F
if			opzioni di scelta:				*
if(x)			1 se x diverso da zero, 0 altrimeni
if(x,a)			a se x diverso da zero, 0 altrimenti
if(x,a,b)		a se x diverso da zero, b altrimenti
if(x,a,b,c)		a se x > 0, b se x è zero, c se x < 0
int(x)			converte x in un intero [ troncamento ]		I
isnull(x)               controlla se x = NULL
log(x)			logaritmo naturale di x				F
log(x,b)		logaritmo di x in base b			F
max(x,y[,z...])		il valore massimo tra quelli elencati		*
median(x,y[,z...])	il valore mediano tra quelli elencati		*
min(x,y[,z...])		il valore minimo tra quelli elencati		*
mode(x,y[,z...])        il valore modale tra quelli elencati            *
not(x)			1 se x è zero, 0 altrimenti
pow(x,y)		x elevato y					*
rand(a,b)		valore casuale x : a <= x < b
round(x)		arrotonda x all'intero più vicino		I
sin(x)			seno di x (x è in gradi)			F
sqrt(x)			radice quadrata di x				F
tan(x)			tangente di x (x è in gradi)			F
xor(x,y)		or esclusivo (XOR) di x e y			I
Variabili interne:
 row()                  riga corrente della finestra mobile
 col()                  colonna corrente della finestra mobile
 x()                    coordinata x corrente della finestra mobile
 y()                    coordinata y corrente della finestra mobile
 ewres()                risoluzione corrente est-ovest
 nsres()                risoluzione corrente nord-sud
 null()                 valore NULL
Si noti che l'indicizzazione di row() e col() inizia da 1.

VALORI A VIRGOLA MOBILE NELL'ESPRESSIONE

Nell'espressione sono consentiti numeri a virgola mobile. Un numero a virgola mobile è un numero che contiene un separatore decimale:
    2.3   12.0   12.   .81
Nell'espressione i valori a virgola mobile vengono trattati in una maniera particolare. Con gli operatori aritmetici e logici, se uno dei due operandi è di tipo float, l'altro viene convertito in float e il risultato dell'operazione è un valore di tipo float. Ciò significa, in particolare, che il risultato di una divisione fra interi è un intero (troncato), mentre il risultato di una divisione fra valori di tipo float è un valore accurato a virgola mobile. Con la funzione di tipo * (si veda la tabella precedente), il risultato è float se almeno un argomento è un valore di tipo float, altrimenti è un intero.

Da notare: se si eseguono i calcoli con numeri interi la mappa risultante sarà costituita da interi. Se si vuole ottenere un risultato con numeri a virgola mobile, si deve aggiungere il separatore decimale ai numeri interi.

Il risultato di una divisione sarà a virgola mobile se almeno uno degli argomenti è un valore a virgola mobile. Moltiplicando uno dei due per 1.0 si ottiene un riusultato a virgola mobile, così come quando si usa la funzione float():

      r.mapcalc "ndvi=float(lsat.4 - lsat.3) / (lsat.4 + lsat.3)"

Informazioni sul valore NULL

Informazioni su NULL: notare che ogni operazione matematica effettuata con celle NULL dà come risultato un valore NULL per queste celle. Per sostituire una cella NULL "al volo", usare la funzione di test isnull() in un'istruzione if.

Esempio: si vuole che le celle con valore NULL siano trattate come se avessero valore zero. Per sommare le mappe A e B (dove B contiene valori NULL) per ottenere una mappa C l'utente può usare una costruzione come:

C=A + if(isnull(B),0,B)

NULL e condizioni:

Per la forma con un argomento:

if(x) = NULL		se x è NULL
if(x) = 0		se x = 0
if(x) = 1		altrimenti (i.e. x non è nè NULL nè 0).

Per la forma con due argomenti:

if(x,a) = NULL		se x è NULL
if(x,a) = 0		se x = 0
if(x,a) = a		altrimenti (i.e. x non è nè NULL nè 0).

Per la forma con tre argomenti:

if(x,a,b) = NULL	se x è NULL
if(x,a,b) = b		se x = 0
if(x,a,b) = a		altrimenti (i.e. x non è nè NULL nè 0).

Per la forma con quettro argomenti:

if(x,a,b,c) = NULL	se x è NULL
if(x,a,b,c) = a		se x > 0
if(x,a,b,c) = b		se x = 0
if(x,a,b,c) = c		se x < 0
Più in generale, tutti gli operatori e la maggior parte delle funzioni restituiscono NULL se *almeno uno* dei loro argomenti è NULL.
Le funzioni if(), isnull() e eval() sono eccezioni.
La funzione isnull() restituisce 1 se il suo argomento è NULL e 0 altrimenti. Se si vuole il comportamento opposto, si deve usare l'operatore !, e.g. "!isnull(x)".

Tutte le forme di if() restituiscono NULL se il primo argomento è NULL. Le forme 2, 3 e 4 di if() restituiscono NULL se l'argomento "selezionato" è NULL, e.g.:

if(0,a,b) = b	indipendentemente che a sia NULL
if(1,a,b) = a	indipendentemente che b sia NULL
eval() restituisce sempre il suo ultimo argomento, così restituisce solo NULL se l'ultimo argomento è NULL.

Nota: L'utente non può testare NULL usando l'operatore ==, poiché questo restituisce NULL se uno o entrambi gli argomenti sono NULL, i.e. se x e y sono entrambi NULL, "x == y" e "x != y" sono entrambi NULL piuttosto che rispettivamente 1 e 0.
Questo comportamento ha senso se l'utente considera NULL come rappresentante una quantità non nota. E.g. se x e y sono entrambi non noti, anche i valori di "x == y" e "x != y" sono non noti; se entrambi hanno valori non noti, l'utente non sa se hanno o no lo stesso valore.

NOTE

Bisogna prestare particola attenzione nel caso in cui l'espressione sia formulata sulla riga di comando. Alcuni caratteri nella shell UNIX hanno un significato speciale. Tra questi caratteri sono ricompresi, tra l'altro:

* ( ) > & |

Si raccomanda di racchiudere le espressioni tra apici singoli; e.g.:

result = 'elevation * 2'
Senza apici, *, che ha un significato speciale per la shell UNIX, verrebbe alterato e r.mapcalc vedrebbe qualcos'altro al posto di *.

In generale, è preferibile fare tutto ciò che si può fare in un unico comando r.mapcalc. E.g. piuttosto che:

        r.mapcalc "$GIS_OPT_OUTPUT.r = r#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * r#$GIS_OPT_SECOND"
        r.mapcalc "$GIS_OPT_OUTPUT.g = g#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * g#$GIS_OPT_SECOND"
        r.mapcalc "$GIS_OPT_OUTPUT.b = b#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * b#$GIS_OPT_SECOND"
sarebbe meglio usare:
		r.mapcalc <<EOF
        $GIS_OPT_OUTPUT.r = r#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * r#$GIS_OPT_SECOND
        $GIS_OPT_OUTPUT.g = g#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * g#$GIS_OPT_SECOND
        $GIS_OPT_OUTPUT.b = b#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * b#$GIS_OPT_SECOND
        EOF
poiché la seconda forma leggerà ogni mappa di input solo una volta. Se l'input viene direttamente dalla tastiera e il tematismo raster risultato esiste, all'utente verrà chiesto se può essere sovrascritto. Altrimenti, il tematismo raster risultato, se esistente, verrà sovrascritto automaticamente.

Non è consentito racchiudere risultato fra apici, comunque non è mai necessario farlo poiché viene sempre riconosciuto come nome di tematismo raster.

Per le formule che l'utente immette dallo standard input (piuttosto che da riga di comando), ora c'è una funzionalità per la continuazione di riga. Se l'utente aggiunge \ alla fine di una riga di input, r.mapcalc assume che la formula che l'utente sta immettendo continua sulla prossima riga di input. Non vi sono limiti alle possibili righe di input o alla lunghezza di una formula.

Se la formula r.mapcalc immessa dall'utente è molto lunga, il titolo della mappa ne conterrà solo una parte, ma la maggior parte della formula (se non tutta) verrà inserita nel file della cronologia della mappa risultato.

Quando l'utente immette un'input per r.mapcalc in modo non interattivo sulla riga di comando, il programma non avvisa l'utente della possibile sovrascrittura di tematismi esistenti. Gli utenti dovrebbero perciò avere l'accortezza di assegnare nell'output del programma nomi di tematismi raster non ancora presenti nel mapset corrente.

La variabile d'ambiente GRASS_RND_SEED is read to initialise the random number generator.

ESEMPI

Per calcolare la media di due tematismi raster a e b:
ave = (a + b)/2
Per formare la media pesata:
ave = (5*a + 3*b)/8.0
Per produrre una rappresentazione binaria del tematismo raster a in modo che la categoria 0 rimanga 0 tutte le altre categorie diventino 1:
mask = a != 0
Questo potrebbe realizzato anche con:
mask = if(a)
Per mascherare il tematismo raster b col tematismo raster a:
result = if(a,b)
Per sostituire tutti i valori inferiori a 5 con NULL:
newmap = if(map<5, null(), 5)
La funzione graph() permette agli utenti di specificare una conversione x-y usando una coppia di coordinate x,y. In alcune situazioni una trasformazione da un valore a un altro non si può stabilire facilmente con un procedimeento matematico, ma può essere rappresentata da un grafico 2-D e quindi interpolata linearmente. La funzione graph() fornisce l'opportunità di realizzare questo. Alla funzione graph viene fornito un valore dell'asse x, assieme al grafico associato rappresentato da una serie di coppie x,y. I valori della x devono assumere un andamento monotono crescente (ognuno maggiore o uguale al precedente). La funzione graph interpola linearmente fra coppie. Per ogni valore di x più basso del più basso valore di x (i.e. il primo) verrà restituito il valore associato di y. Per ogni valore di x più alto dell'ultimo verrà analogamente restituito il valore y associato. Si consideri l'istanza:
newmap = graph(map, 1,10, 2,25, 3,50)
Vengono forniti i valori X (map) e vengono restituiti i valori y (newmap):
0, 10
1, 10
1.5, 17.5
2.9, 47.5
4, 50
100, 50

BUG

Le righe che continuano devono terminare con un \ e non devono avere NESSUN spazio bianco finale (blank o tab). Se l'utente non toglie lo spazio bianco alla fine delle righe che devono continuare, r.mapcalc produrrè un messaggio di errore incomprensibile e l'equazione non funzionerè come dovrebbe. Questo è importante per la funzione eval().

I messaggi di errore prodotti da r.mapcalc sono praticamente inutili. In futuro, r.mapcalc dovrebbe tentare di indicare all'utente la parte dell'equazione dove si è verificato l'errore, e.g.:

x = a * b ++ c
ERROR: da qualche parte nella riga 1: ...  b ++ c ...

Al momento non ci sono in r.mapcalc meccanismi per la generazione di commenti. Forse il trucco sarebbe quello di aggiungere una funzionalità per ignorare l'intera riga, come se non fosse presente, all'inserimento di un # all'inizio della riga..

La funzione dovrebbe richiedere all'utente di digitare "end" o "exit" invece di lasciare semplicemente una riga vuota, permettendo di eseguire la separazione di script multipli separati da uno spazio bianco.

r.mapcalc does not print a warning in case of operations on NULL cells. It is left to the user to utilize the isnull() function.

VEDERE ANCHE

r.mapcalc: An Algebra for GIS and Image Processing, by Michael Shapiro and Jim Westervelt, U.S. Army Construction Engineering Research Laboratory (March/1991).

Performing Map Calculations on GRASS Data: r.mapcalc Program Tutorial, by Marji Larson, Michael Shapiro and Scott Tweddale, U.S. Army Construction Engineering Research Laboratory (December 1991)

La conversione in scala di grigi è basata sul sistema C.I.E. x,y,z dove y rappresenta la luminosità. Si veda "Fundamentals of Digital Image Processing," by Anil K. Jain (Prentice Hall, NJ, 1989; p 67).

g.region, r.bitpattern, r.blend, r.colors, r.fillnulls

AUTHORS

Michael Shapiro, U.S.Army Construction Engineering Research Laboratory

Glynn Clements

Last changed: $Date: 2011-11-08 12:29:50 +0100(mar, 08 nov 2011) $


Main index - raster index - Full index

© 1999-2009 GRASS Development Team