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.
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
[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.
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.)
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.
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
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
2.3 12.0 12. .81
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)"
x &&& falso == falso falso &&& x == falso x ||| vero == vero vero ||| x == vero
if(x) NULL se x è NULL; 0 se x è zero; 1 altrimenti if(x,a) NULL se x è NULL; a se x è diverso da zero; 0 altrimenti if(x,a,b) NULL se x è NULL; a se x è diverso da zero; b altrimenti if(x,n,z,p) NULL se x è NULL; n se x è negativo; z se x è zero; p se x è positivo
Esempi: log(-2) sqrt(-2) pow(a,b) dove a è negativo e b non è un intero
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
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
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.
* ( ) > & |
Si raccomanda di racchiudere le espressioni tra apici singoli; e.g.:
result = 'elevation * 2'
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"
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
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.
ave = (a + b)/2
ave = (5*a + 3*b)/8.0
mask = a != 0
mask = if(a)
result = if(a,b)
newmap = if(map<5, null(), 5)
newmap = graph(map, 1,10, 2,25, 3,50)
0, 10 1, 10 1.5, 17.5 2.9, 47.5 4, 50 100, 50
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.
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
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