r.mapcalcgrass - Online în cloud

PROGRAM:

NUME

r.mapcalc - Calculator de hartă raster.

CUVINTE CHEIE

raster, algebră

REZUMAT

r.mapcalc
r.mapcalc --Ajutor
r.mapcalc [-s] [expresie=şir] [fişier=nume] [sămânţă=întreg] [-suprascrie]
[--ajutor] [-prolix] [-liniştit] [-ui]

Steaguri:
-s
Generați semințe aleatorii (rezultatul este nedeterminist)

--sobrescrie
Permiteți fișierelor de ieșire să suprascrie fișierele existente

--Ajutor
Imprimați rezumatul utilizării

--verbos
Ieșire modulară

--Liniște
Ieșire silențioasă a modulului

--ui
Forțați lansarea dialogului GUI

parametri:
expresie=şir
Expresie de evaluat

fişier=nume
Fișier care conține expresiile de evaluat

sămânţă=întreg
Sămânță pentru funcția rand().

DESCRIERE

r.mapcalc efectuează aritmetica pe straturi de hărți raster. Pot fi create noi straturi de hartă raster
care sunt expresii aritmetice care implică straturi de hartă raster existente, întregi sau plutitoare
constante de punct și funcții.

Program utilizare
r.mapcalc expresia are forma:

rezultat = expresie

Unde rezultat este numele unui strat de hartă raster care conține rezultatul calculului
si expresie este orice expresie aritmetică legală care implică straturi de hartă raster existente
(cu exceptia rezultat în sine), constante întregi sau în virgulă mobilă și funcții cunoscute de
calculator. Parantezele sunt permise în expresie și pot fi imbricate la orice adâncime.
rezultat va fi creat în setul de hărți curent al utilizatorului.

As expresie= este prima opțiune, este cea implicită. Aceasta înseamnă că trecerea unui
expresia pe linia de comandă este posibilă atâta timp cât expresia este citată și un spațiu
este inclus înaintea primei = semn. Exemplu („foo” este harta rezultată):
r.mapcalc "foo = 1"
sau:
r.mapcalc 'foo = 1'
O expresie fără ghilimele (adică împărțită pe mai multe argumente) nu va funcționa și nici omiterea nu va funcționa
spațiul dinaintea semnului =:
r.mapcalc 'foo=1'
scuze, nu este un parametru valid
Pentru a citi comanda din fișier, utilizați în mod explicit file=, de exemplu:
r.mapcalc file=fișier
sau:
r.mapcalc fisier=- < fisier
sau:
fișier r.mapcalc=- <
foo = 1
EOF

Formula introdusă la r.mapcalc de către utilizator este înregistrată atât în rezultat titlul hărții
(care apare în fișierul de categorie pentru rezultat) și în fișierul istoric pentru rezultat.

Unele caractere au o semnificație specială pentru shell-ul de comandă. Dacă utilizatorul introduce intrare
la r.mapcalc pe linia de comandă, expresiile ar trebui să fie incluse între ghilimele simple.
Vezi NOTE, mai jos.

Operatorii si comandă of precedenta
Sunt acceptați următorii operatori:
Operator Semnificație Tip Precedență
-------------------------------------------------- ------------
- Aritmetica negației 12
~ complementul pe biți 12
! nu este logic 12
^ Aritmetica exponentiatiei 11
% modul aritmetică 10
/ diviziune Aritmetica 10
* înmulțirea aritmetică 10
+ Aritmetica de adunare 9
- scăderea aritmetică 9
<< deplasare la stânga pe biți 8
>> deplasare la dreapta pe biți 8
>>> deplasare la dreapta (fără semn) Bitwise 8
> mai mare decât logic 7
>= mai mare sau egal Logic 7
< mai puțin decât logic 7
<= mai mic sau egal Logic 7
== egal logic 6
!= nu este egal logic 6
& pe biți și pe biți 5
| pe biți sau pe biți 4
&& logic și logic 3
&&& logic și[1] logic 3
|| logic sau logic 2
||| logic sau[1] logic 2
?: logic condiționat 1
(modulul este restul la diviziune)

[1] &&& și ||| operatorii gestionează valorile nule în mod diferit față de alți operatori. Vezi
secțiunea intitulată NULL a sustine mai jos pentru mai multe detalii.

Operatorii sunt aplicați de la stânga la dreapta, cu cei cu prioritate mai mare aplicați
înaintea celor cu prioritate mai mică. Împărțirea cu 0 și modulul cu 0 sunt acceptabile și
da un rezultat NULL. Operatorii logici dau un rezultat 1 dacă comparația este adevărată, 0
in caz contrar.

Raster Hartă strat nume
Orice din expresie care nu este un număr, un operator sau un nume de funcție este preluat
să fie un nume de strat de hartă raster. Exemple:

elevație
x3
3d.lui

Majoritatea straturilor de hartă raster GRASS îndeplinesc această convenție de denumire. Cu toate acestea, dacă un strat de hartă raster
are un nume care intră în conflict cu regula de mai sus, trebuie citat. De exemplu, cel
expresie

x = ab

ar fi interpretat ca: x este egal cu minus b, în ​​timp ce

x = „ab”

ar fi interpretat ca: x este egal cu stratul hărții raster numit ab

De asemenea

x = 3107

ar crea x completat cu numărul 3107, în timp ce

x = "3107"

ar copia stratul hărții raster 3107 la stratul hartă raster x.

Nu sunt necesare ghilimele decât dacă numele stratului de hartă raster arată ca numere sau conţin
operatori, SAU dacă programul nu este rulat în mod non-interactiv. Exemplele date aici presupun că
programul este rulat interactiv. Vezi NOTE, mai jos.

r.mapcalc va căuta straturile hărții raster în funcție de setul de hărți curent al utilizatorului
cale de căutare. Este posibil să suprascrieți calea de căutare și să specificați setul de hărți din care
pentru a selecta stratul hartă raster. Acest lucru se face prin specificarea numelui stratului hărții raster în
forma:

nume@mapset

De exemplu, următoarea este o expresie legală:

rezultat = x@PERMANENT / y@SOILS

Setul de hărți specificat nu trebuie să se afle în calea de căutare a setului de hărți. (Această metodă de
suprascrierea căii de căutare mapset este comună tuturor comenzilor GRASS, nu doar r.mapcalc.)

Cartier schimbare
Hărțile și imaginile sunt fișiere de bază de date stocate în format raster, adică bidimensionale
matrice de valori întregi. În r.mapcalc, hărțile pot fi urmate de a Cartier schimbare
care specifică un offset relativ față de celula curentă evaluată. Formatul este
harta[r,c], În cazul în care r este decalajul rândului și c este decalajul coloanei. De exemplu, harta[1,2]
se referă la celula cu un rând de mai jos și două coloane în dreapta celulei curente,
harta[-2,-1] se referă la celula două rânduri deasupra și o coloană la stânga curentului
celulă, și harta[0,1] se referă la celula pe o coloană din dreapta celulei curente. Acest
sintaxa permite dezvoltarea filtrelor de tip vecinătate într-o singură hartă sau peste tot
hărți multiple.

Raster Hartă strat Valorile din il categorie fişier
Uneori este de dorit să se folosească o valoare asociată cu cea a unei categorii etichetă în loc de
valoarea categoriei în sine. Dacă numele unui strat de hartă raster este precedat de @ operator, apoi
etichetele din fișierul de categorii pentru stratul hartă raster sunt utilizate în expresie în loc de
valoarea categoriei.

De exemplu, să presupunem că stratul hartă raster sol.ph (reprezentând valorile pH-ului solului) are a
fișier de categorie cu etichete după cum urmează:

eticheta pisicii
------------------
0 fara date
1 1.4
2 2.4
3 3.5
4 5.8
5 7.2
6 8.8
7 9.4

Apoi expresia:

rezultat = @soils.ph

ar produce un rezultat cu valorile categoriei 0, 1.4, 2.4, 3.5, 5.8, 7.2, 8.8 și 9.4.

Rețineți că acest operator poate fi aplicat numai straturilor de hărți raster și produce o plutire
valoarea punctului din expresie. Prin urmare, eticheta categoriei trebuie să înceapă cu un valid
număr. Dacă eticheta categoriei este întreagă, aceasta va fi reprezentată printr-o virgulă mobilă
număr. Eticheta categoriei nu începe cu un număr sau lipsește, va fi
reprezentat prin NULL (fără date) în harta raster rezultată.

Gri scară echivalente si culoare separă
Este adesea util să manipulați culorile atribuite categoriilor de hărți. Aceasta este
deosebit de util atunci când proprietățile spectrale ale celulelor au sens (ca și în cazul imaginilor
date), sau când valorile categoriei hărții reprezintă cantități reale (ca atunci când valorile categoriei
reflectă valorile reale de altitudine). Manipularea culorilor hărții poate ajuta, de asemenea, recunoașterea vizuală,
și imprimarea hărților.

Operatorul # poate fi folosit fie pentru a converti valorile categoriilor de hartă la scara lor de gri
echivalente sau pentru a extrage componentele roșii, verzi sau albastre ale unui strat de hartă raster în
straturi separate de hartă raster.

rezultat = #hartă

convertește valoarea fiecărei categorii în Hartă la o valoare în intervalul 0-255 care reprezintă
nivel de gri implicat de culoarea categoriei. Dacă harta are o culoare în scară de gri
tabel, atunci nivelul de gri este ceea ce evaluează #map. În caz contrar, se calculează astfel:

0.10 * roșu + 0.81 * verde + 0.01 * albastru

Alternativ, puteți utiliza:

rezultat = y#map

pentru a utiliza ponderile NTSC:

0.30 * roșu + 0.59 * verde + 0.11 * albastru

Sau puteți folosi:

rezultat = i#map

pentru a utiliza ponderi egale:

0.33 * roșu + 0.33 * verde + 0.33 * albastru

Operatorul # are alte trei forme: r#map, g#map, b#map. Acestea extrag roșu, verde,
sau componente albastre în harta raster numită, respectiv. Scriptul GRASS shell r.amestec
extrage fiecare dintre aceste componente din două straturi de hartă raster și le combină prin a
procent specificat de utilizator. Aceste forme permit realizarea unor separații de culoare. De exemplu, să
extrage componenta roșie din Hartă și stocați-l în noul strat de hartă 0-255 roșu, utilizatorul
ar putea tasta:

roșu = r#map

Pentru a atribui culorilor gri acestei hărți, tastați:

r.colors map=culoare rosie=reguli
negru
alb

Pentru a atribui acestei hărți culori roșii, tastați:

r.colors map=culoare rosie=reguli
negru
roșu

funcţii
Funcțiile acceptate în prezent sunt enumerate în tabelul de mai jos. Tipul rezultatului
este indicat în ultima coloană. F înseamnă că funcțiile au ca rezultat întotdeauna o plutire
valoarea punctului, I înseamnă că funcția dă un rezultat întreg și * indică faptul că
rezultatul este float dacă oricare dintre argumentele funcției sunt valori în virgulă mobilă și
întreg dacă toate argumentele sunt întregi.

tip de descriere a funcției
-------------------------------------------------- -------------------------
abs(x) returnează valoarea absolută a lui x *
acos(x) cosinus invers al lui x (rezultatul este în grade) F
asin(x) sinus invers al lui x (rezultatul este în grade) F
atan(x) tangenta inversă a lui x (rezultatul este în grade) F
atan(x,y) tangenta inversă a lui y/x (rezultatul este în grade) F
cos(x) cosinusul lui x (x este în grade) F
double(x) convertiți x în virgulă mobilă de precizie dublă F
eval([x,y,...,]z) evaluează valorile expr listate, transmite rezultatele la z
exp(x) funcția exponențială a lui x F
exp(x,y) x la puterea y F
float(x) convertește x în virgulă mobilă cu precizie unică F
graph(x,x1,y1[x2,y2..]) convertește x în ay pe baza punctelor dintr-un grafic F
graph2(x,x1[,x2,..],y1[,y2..])
forma alternativă a graficului () F
dacă opțiuni de decizie: *
if(x) 1 dacă x nu este zero, 0 în caz contrar
if(x,a) a dacă x nu este zero, 0 în caz contrar
if(x,a,b) a dacă x nu este zero, b în caz contrar
if(x,a,b,c) a dacă x > 0, b dacă x este zero, c dacă x < 0
int(x) convertiți x în întreg [ trunchie ] I
isnull(x) verifica dacă x = NULL
log(x) log natural al lui x F
log(x,b) log al bazei x b F
max(x,y[,z...]) cea mai mare valoare dintre cele enumerate *
mediana(x,y[,z...]) valoarea mediană a celor enumerate *
min(x,y[,z...]) cea mai mică valoare dintre cele enumerate *
mode(x,y[,z...]) valoarea modului celor enumerate *
nmax(x,y[,z...]) cea mai mare valoare dintre cele enumerate, excluzând NULL-urile *
nmedian(x,y[,z...]) valoarea mediană a celor enumerate, excluzând NULL-urile *
nmin(x,y[,z...]) cea mai mică valoare dintre cele enumerate, excluzând NULL-urile *
nmode(x,y[,z...]) valoarea modului celor enumerate, excluzând NULL-urile *
not(x) 1 dacă x este zero, 0 în caz contrar
pow(x,y) x la puterea y *
rand(a,b) valoare aleatoare x : a <= x < b *
rotunjește(x) rotunjește x la cel mai apropiat număr întreg I
rotunjește(x,y) rotunjește x la cel mai apropiat multiplu al lui y
rotunjește(x,y,z) rotunjește x la cel mai apropiat y*i+z pentru un întreg i
sin(x) sinusul lui x (x este în grade) F
sqrt(x) rădăcină pătrată a lui x F
tan(x) tangenta lui x (x este în grade) F
xor(x,y) exclusiv-sau (XOR) pentru x și y I
Variabile interne:
row() rândul curent al ferestrei în mișcare
col() col actual al ferestrei în mișcare
x() coordonata x curentă a ferestrei în mișcare
y() coordonata y curentă a ferestrei în mișcare
ewres() rezoluție actuală est-vest
nsres() rezoluție actuală nord-sud
null() valoare NULL
Rețineți că indexarea row() și col() începe cu 1.

plutitor punct Valorile in il expresie
Numerele cu virgulă mobilă sunt permise în expresie. Un număr în virgulă mobilă este un număr
care conține un punct zecimal:
2.3 12.0 12. .81
Valorile în virgulă mobilă din expresie sunt tratate într-un mod special. Cu aritmetica si
operatori logici, dacă unul dintre operanzi este float, celălalt este convertit în float și
rezultatul operațiunii este flotant. Aceasta înseamnă, în special, că împărțirea numerelor întregi
rezultă într-un număr întreg (trunchiat), în timp ce împărțirea elementelor flotante are ca rezultat o flotație precisă
valoarea punctului. Cu funcții de tip * (vezi tabelul de mai sus), rezultatul este float dacă există
argumentul este float, în caz contrar întreg.

Notă: Dacă calculați cu numere întregi, harta rezultată va fi întreagă. daca tu
doriți să obțineți un rezultat flotant, adăugați punctul zecimal la numerele întregi.

Dacă doriți divizare în virgulă mobilă, cel puțin unul dintre argumente trebuie să fie unul flotant
valoarea punctului. Înmulțirea unuia dintre ele cu 1.0 va produce un rezultat în virgulă mobilă, la fel și
folosind float():
r.mapcalc "ndvi = float(lsat.4 - lsat.3) / (lsat.4 + lsat.3)"

NULL a sustine
· Împărțirea cu zero ar trebui să aibă ca rezultat NULL.

· Modulul cu zero ar trebui să aibă ca rezultat NULL.

· Valorile NULL în orice operație aritmetică sau logică ar trebui să aibă ca rezultat NULL.
(cu toate acestea, &&& și ||| sunt tratate special, așa cum este descris mai jos).

· &&& și ||| operatorii observă următoarele axiome chiar și atunci când x este NULL:
x &&& fals == fals
fals &&& x == fals
x ||| adevărat == adevărat
adevărat ||| x == adevărat

· Valorile NULL din argumentele funcției ar trebui să aibă ca rezultat NULL (cu toate acestea, if(), eval() și
isnull() sunt tratate special, așa cum este descris mai jos).

· Funcția eval() returnează întotdeauna ultimul argument

· Situația pentru if() este:
daca(x)
NULL dacă x este NULL; 0 dacă x este zero; 1 altfel
daca(x,a)
NULL dacă x este NULL; a dacă x este diferit de zero; 0 altfel
dacă(x,a,b)
NULL dacă x este NULL; a dacă x este diferit de zero; b altfel
dacă(x,n,z,p)
NULL dacă x este NULL; n dacă x este negativ;
z dacă x este zero; p dacă x este pozitiv

· Funcția (nouă) isnull(x) returnează: 1 dacă x este NULL; 0 altfel. Noul)
funcția null() (care nu are argumente) returnează un număr întreg NULL.

· Argumentele non-NULL, dar invalide, pentru funcții ar trebui să aibă ca rezultat NULL.
Exemple:
jurnal(-2)
sqrt(-2)
pow(a,b) unde a este negativ și b nu este un număr întreg

Suport NULL: Vă rugăm să rețineți că orice matematică efectuată cu celule NULL are întotdeauna ca rezultat un NULL
valoare pentru aceste celule. Dacă doriți să înlocuiți o celulă NULL din mers, utilizați isnull()
funcția de testare într-o instrucțiune if.

Exemplu: Utilizatorii doresc ca celulele cu valori NULL să fie tratate ca zerouri. Pentru a adăuga hărțile A și
B (unde B conține valori NULL) pentru a obține o hartă C, utilizatorul poate folosi o construcție ca:

C = A + dacă(este null(B),0,B)

NULL si Condiții:

Pentru forma cu un singur argument:
if(x) = NULL dacă x este NULL
dacă (x) = 0 dacă x = 0
if(x) = 1 altfel (adică x nu este nici NULL, nici 0).

Pentru forma cu două argumente:
if(x,a) = NULL dacă x este NULL
dacă (x,a) = 0 dacă x = 0
if(x,a) = a altfel (adică x nu este nici NULL, nici 0).

Pentru forma cu trei argumente:
if(x,a,b) = NULL dacă x este NULL
dacă (x,a,b) = b dacă x = 0
if(x,a,b) = a altfel (adică x nu este nici NULL, nici 0).

Pentru forma cu patru argumente:
if(x,a,b,c) = NULL dacă x este NULL
dacă(x,a,b,c) = a dacă x > 0
dacă (x,a,b,c) = b dacă x = 0
dacă (x,a,b,c) = c dacă x < 0
În general, toți operatorii și majoritatea funcțiilor returnează NULL dacă * oricare* dintre argumentele lor
sunt NULL.
Funcțiile if(), isnull() și eval() sunt excepții.
Funcția isnull() returnează 1 dacă argumentul său este NULL și 0 în caz contrar. Dacă utilizatorul
vrea opusul, ! trebuie folosit operator, de exemplu „!isnull(x)”.

Toate formele de if() returnează NULL dacă primul argument este NULL. Formele de argument 2, 3 și 4
of if() return NULL dacă argumentul „selectat” este NULL, de exemplu:
if(0,a,b) = b indiferent dacă a este NULL
if(1,a,b) = a indiferent dacă b este NULL
eval() returnează întotdeauna ultimul argument, deci returnează NULL numai dacă ultimul argument este
NUL.

notițe: Utilizatorul nu poate testa NULL folosind operatorul ==, deoarece acesta returnează NULL dacă oricare dintre ele
sau ambele argumente sunt NULL, adică dacă x și y sunt ambele NULL, atunci „x == y” și „x != y” sunt
atât NULL, decât 1 și, respectiv, 0.
Comportamentul are sens dacă utilizatorul consideră NULL ca reprezentând o cantitate necunoscută.
De exemplu, dacă x și y sunt ambele necunoscute, atunci valorile lui „x == y” și „x != y” sunt de asemenea
necunoscut; dacă ambele au valori necunoscute, utilizatorul nu știe dacă sunt sau nu
au aceeasi valoare.

NOTE

Folosire din comandă linie
O atenție suplimentară trebuie avută dacă expresia este dată pe linia de comandă. Unele personaje
au o semnificație specială pentru shell-ul UNIX. Acestea includ, printre altele:
* ( ) > & |

Este recomandabil să puneți ghilimele simple în jurul expresiei; de exemplu:
„rezultat = altitudine * 2”
Fără ghilimele, *, care are o semnificație specială pentru shell-ul UNIX, ar fi modificat
si r.mapcalc ar vedea altceva decât *.

Multiplu calcule
În general, este de preferat să faceți cât mai mult posibil în fiecare comandă r.mapcalc. De exemplu
Decat:
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"

utilizați:
r.mapcalc <
$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

deoarece acesta din urmă va citi fiecare hartă de intrare o singură dată.

Înapoi compatibilitate
Pentru compatibilitatea cu GRASS 6, dacă nu se oferă opțiuni, produce
file=- (care citește din stdin), astfel încât să puteți continua să utilizați de exemplu:
r.mapcalc < fisier
sau:
r.mapcalc <
foo = 1
EOF
Dar dacă nu aveți nevoie de compatibilitate cu versiunile anterioare GRASS GIS, utilizați în mod explicit fișier=,
după cum s-a afirmat mai sus.

Când numele hărții conține litere mari sau un punct care nu este permis
nume de opțiuni de modul, the r.mapcalc comanda va fi valabilă și fără ghilimele:
r.mapcalc cota_A=1
r.cota mapcalc.1=1
Cu toate acestea, această sintaxă nu este recomandată, deoarece ghilimele, așa cum s-a menționat mai sus, sunt mai sigure. Folosind ghilimele
este atât compatibil cu retroactiv, cât și valabil în viitor.

Interactiv intrare in comandă linie
Pentru formulele pe care utilizatorul le introduce din intrarea standard (mai degrabă decât din linia de comandă),
acum există o caracteristică de continuare a liniei. Dacă utilizatorul adaugă o bară oblică inversă la sfârșitul unui
linie de intrare, r.mapcalc presupune că formula introdusă de utilizator continuă
următoarea linie de intrare. Nu există limită pentru numărul posibil de linii de intrare sau pentru
lungimea unei formule.

În cazul în care r.mapcalc formula introdusă de utilizator este foarte lungă, titlul hărții va conține doar
unele dintre ele, dar majoritatea (dacă nu toate) formulei vor fi plasate în fișierul istoric pentru
il rezultat hartă.

Când utilizatorul introduce intrarea în r.mapcalc non-interactiv pe linia de comandă, programul
nu va avertiza utilizatorul să nu suprascrie straturile existente ale hărții. Prin urmare, utilizatorii ar trebui să ia
grijă să atribuiți ieșirilor programului nume de hărți raster care nu există încă în actualul lor
seturi de hărți.

Raster MASCA manipulare
r.mapcalc urmează comportamentul obișnuit GRASS al manipulării raster MASK, deci MASK este doar
aplicat la citirea unei hărți raster GRASS existente. Aceasta înseamnă că, de exemplu,
comanda:
r.mapcalc „elevation_exaggerated = elevație * 3”
creați o hartă respectând pixelii mascați dacă MASK este activ.

Cu toate acestea, atunci când creați o hartă care nu se bazează pe nicio hartă, de exemplu, o hartă dintr-o constantă:
r.mapcalc "înălțimea_bază = 200.0"
harta raster creată este limitată doar de o regiune de calcul, dar nu este afectată de
o MASCA activa. Acest lucru este de așteptat deoarece, așa cum sa menționat mai sus, MASCA este aplicată numai atunci când
citind, nu atunci când scrieți o hartă raster.

Dacă și în acest caz ar trebui aplicată MASCA, o instrucțiune if() care include MASCA
ar trebui folosit, de exemplu:
r.mapcalc "înălțimea_bază = if(MASK, 200.0, null())"
Când testați expresiile legate de MASC, rețineți că atunci când MASC este activ, nu vedeți
date în zone mascate chiar dacă nu sunt NULL. Vedea r.masca pentru detalii.

eval funcţie
Dacă rezultatul calculului ar trebui să fie doar o hartă, dar expresia este atât de complexă
că este mai bine să-l împărțiți în mai multe expresii, se poate folosi funcția eval:
r.mapcalc << EOF
eval(elev_200 = altitudine - 200,
elev_5 = 5 * altitudine,
elev_p = pow(elev_5, 2))
elevation_result = (0.5 * elev_200) + 0.8 * elev_p
EOF
Acest exemplu folosește sintaxa << EOF de tip Unix pentru a furniza intrare r.mapcalc.

Rețineți că variabilele temporare (hărțile) nu sunt create și, prin urmare, nu contează
indiferent dacă ele există sau nu. În exemplul de mai sus, dacă harta elev_200 există, nu va fi
suprascris și nu va fi generată nicio eroare. Motivul este că numele elev_200 acum
denotă variabila temporară (harta) și nu harta existentă. Următoarele părți ale
expresia va folosi elev_200 temporar, iar elev_200 existent va rămâne intact
și nu vor fi folosite. Dacă un utilizator dorește să folosească harta existentă, numele temporar
variabila (harta) trebuie schimbată.

Întâmplător număr generator inițializare
Generatorul de numere pseudoaleatoare utilizat de funcția rand() poate fi inițializat la a
valoare specifică folosind sămânţă opțiune. Aceasta poate fi folosită pentru a reproduce un precedent
calcul.

Alternativ, poate fi inițializat din ora sistemului și PID-ul folosind -r steag.
Acest lucru ar trebui să aibă ca rezultat utilizarea unei semințe diferite de fiecare dată.

În ambele cazuri, sămânța va fi scrisă în istoricul hărții și poate fi văzută folosind
r.info.

Dacă doriți ca alte persoane să vă poată verifica rezultatele, este de preferat să utilizați
sămânţă opțiunea de a furniza o sămânță care este fie specificată în script, fie generată dintr-un
proces determenistic, cum ar fi un generator de numere pseudoaleatoare, dat fiind o sămânță explicită.

Rețineți că funcția rand() va genera o eroare fatală dacă nici sămânţă opțiune nici
il -s se dau steagul.

EXEMPLE

Pentru a calcula media a două straturi de hartă raster a si b:
av = (a + b)/2
Pentru a forma o medie ponderată:
av = (5*a + 3*b)/8.0
Pentru a produce o reprezentare binară a stratului hărții raster a astfel încât categoria 0 rămâne 0
și toate celelalte categorii devin 1:
masca = a != 0
Acest lucru ar putea fi realizat și prin:
masca = daca(a)
Pentru a masca stratul hartă raster b prin stratul de hartă raster a:
rezultat = dacă(a,b)
Pentru a schimba toate valorile sub 5 la NULL:
newmap = if(map<5, null(), 5)
Funcția graph() permite utilizatorilor să specifice o conversie xy folosind perechi de x,y
coordonate. În unele situații, o transformare de la o valoare la alta nu este ușor
stabilit matematic, dar poate fi reprezentat printr-un grafic 2-D și apoi liniar
interpolat. Funcția graph() oferă posibilitatea de a realiza acest lucru. O axa x
valoarea este furnizată funcției grafic împreună cu graficul asociat reprezentat de a
serie de perechi x,y. Valorile x trebuie să crească monoton (fiecare mai mare decât sau
egal cu precedentul). Funcția grafică interpolează liniar între perechi. Orice x
valoare mai mică valoarea x cea mai mică (adică prima) va avea valoarea y asociată returnată.
Orice valoare x mai mare decât ultima va avea în mod similar valoarea y asociată returnată.
Luați în considerare cererea:
hartă nouă = grafic(hartă, 1,10, 2,25, 3,50)
Valorile X (hartă) furnizate și valorile y (hartă nouă) returnate:
0, 10
1, 10
1.5, 17.5
2.9, 47.5
4, 50
100, 50

CUNOSCUT PROBLEME

Liniile de continuare trebuie să se termine cu \ și au Nu. spații albe în urmă (spații libere sau file). Dacă
utilizatorul lasă spațiu alb la sfârșitul liniilor de continuare, mesajele de eroare
produsă de r.mapcalc va fi lipsit de sens și ecuația nu va funcționa ca utilizator
destinat. Acest lucru este deosebit de important pentru funcția eval().

În prezent, nu există un mecanism de comentarii în r.mapcalc. Poate adăugarea unei capacități care
ar face ca întreaga linie să fie ignorată atunci când utilizatorul a inserat un # la începutul lui a
linia de parcă nu ar fi prezentă, ar face șmecheria.

Funcția ar trebui să solicite utilizatorului să tastați „termină” sau „ieșire” în loc de pur și simplu un gol
linia. Acest lucru ar face separarea mai multor scripturi separabile prin spațiu alb.

r.mapcalc nu tipărește un avertisment în cazul operațiunilor pe celule NULL. Este lăsat pe seama
utilizatorului să utilizeze funcția isnull().

Utilizați r.mapcalcgrass online folosind serviciile onworks.net